多线程总结三:控制线程

Java的线程支持提供了一些便捷的工具方法,通过这些便捷的工具方法可以很好的控制线程的执行。

1、join线程:join
当某个程序执行流中调用其他线程的join()方法时,执行中的线程会被阻塞,直到被join()方法加入的join线程执行
完为止。join()方法将大问题划分为许多小问题,每个小问题分配一个线程,当所有的小问题都得到处理以后,再调用主
线程来进一步操作。

 1 /**
 2  * @Title: JoinThread.java
 3  * @Package
 4  * @author 任伟
 5  * @date 2014-12-8 上午11:23:38
 6  * @version V1.0
 7  */
 8
 9 /**
10  * @ClassName: JoinThread
11  * @Description: join线程
12  * @author 任伟
13  * @date 2014-12-8 上午11:23:38
14  */
15 public class JoinThread extends Thread{
16
17     //提供一个有参数的构造器,用于设置该线程的名字
18     public JoinThread(String name){
19         super(name);
20     }
21
22     /* (non-Javadoc)
23      * @see java.lang.Thread#run()
24      */
25     @Override
26     public void run() {
27         for(int i=0; i<100; i++){
28             System.out.println(this.getName() + " " + i);
29         }
30     }
31
32     public static void main(String[] args) {
33         //启动子线程
34         new JoinThread("新线程").start();
35         for(int i=0; i<100; i++){
36             if(20==i){
37                 JoinThread jt = new JoinThread("被Join的线程");
38                 jt.start();
39                 try {
40                     jt.join();
41                 } catch (InterruptedException e) {
42                     e.printStackTrace();
43                 }
44             }
45             System.out.println(Thread.currentThread().getName()+" "+i);
46         }
47     }
48 }

JoinThread

2、后台线程:setDaemon
后台线程又称为“守护线程”或“精灵线程”。其特征是:如果所有的前台线程都死亡,后台线程会自动死亡。调用Thread
对象的setDaemon(true)方法可以将指定的线程设置为后台线程。前台线程创建的子线程默认是前台线程,后台线程创建的子
线程默认是后台台线程。

 1 /**
 2  * @Title: DaemonThread.java
 3  * @Package
 4  * @author 任伟
 5  * @date 2014-12-8 上午11:41:13
 6  * @version V1.0
 7  */
 8
 9 /**
10  * @ClassName: DaemonThread
11  * @Description: 后台线程
12  * @author 任伟
13  * @date 2014-12-8 上午11:41:13
14  */
15 public class DaemonThread extends Thread {
16     /* (non-Javadoc)
17      * @see java.lang.Thread#run()
18      */
19     @Override
20     public void run() {
21         for(int i=0; i<10000; i++){
22             System.out.println(this.getName()+" "+i);
23         }
24     }
25
26     public static void main(String[] args) {
27         DaemonThread t = new DaemonThread();
28         //将此线程设置为后台线程
29         t.setDaemon(true);
30         t.start();
31
32         for(int i=0; i<10; i++){
33             System.out.println(Thread.currentThread().getName()+" "+i);
34         }
35     }
36 }

DaemonThread

3、线程睡眠:Sleep
当当前线程调用sleep()方法进入阻塞状态以后,该线程不会获得执行的机会,因此sleep()方法常用来暂停程序的执行。

 1 /**
 2  * @Title: SleepTest.java
 3  * @Package
 4  * @author 任伟
 5  * @date 2014-12-8 上午11:53:51
 6  * @version V1.0
 7  */
 8
 9 /**
10  * @ClassName: SleepTest
11  * @Description: 使线程睡眠
12  * @author 任伟
13  * @date 2014-12-8 上午11:53:51
14  */
15 public class SleepTest {
16     public static void main(String[] args) {
17         for(int i=0; i<10; i++){
18             System.out.println("当前时间:" + new Date());
19             try {
20                 Thread.sleep(1000);
21             } catch (InterruptedException e) {
22                 e.printStackTrace();
23             }
24         }
25     }
26 }

SleepTest

4、线程优先级
每个线程执行时都会具有一定的优先级,每个线程默认的优先级都与创建它的父线程优先级相同。Thread类提供了
setPriority(int newPriority)、getPriority()来设置和返回线程优先级。
MAX_PRIORITY: 10
MIN_PRIORITY: 1
NORM_PRIORITY: 5

5、线程让步:yield
yield()让当前线程暂停一下,让系统的线程调度器重新调度一次,当然也可能调度到自己.

 1 /**
 2  * @Title: YieldTest.java
 3  * @Package
 4  * @author 任伟
 5  * @date 2014-12-8 下午12:03:34
 6  * @version V1.0
 7  */
 8
 9 /**
10  * @ClassName: YieldTest
11  * @Description: 线程让步方法测试
12  * @author 任伟
13  * @date 2014-12-8 下午12:03:34
14  */
15 public class YieldTest extends Thread{
16
17     public YieldTest(String name){
18         super(name);
19     }
20
21     public void run() {
22         for(int i=0; i<50; i++){
23             System.out.println(this.getName()+" "+i);
24             //当i=20,使用yield()方法让当前线程让步
25             if(20==i){
26                 Thread.yield();
27             }
28         }
29     }
30
31     public static void main(String[] args) {
32         YieldTest yt1 = new YieldTest("线程1");
33         YieldTest yt2 = new YieldTest("线程2");
34         yt1.setPriority(Thread.MAX_PRIORITY);
35         yt2.setPriority(Thread.MIN_PRIORITY);
36
37
38         yt1.start();
39         yt2.start();
40     }
41 }

YieldTest

时间: 2024-10-08 01:20:16

多线程总结三:控制线程的相关文章

Java 多线程(三) 线程的生命周期及优先级

Java 多线程(三) 线程的生命周期及优先级 线程的生命周期 线程的生命周期:一个线程从创建到消亡的过程. 如下图,表示线程生命周期中的各个状态: 线程的生命周期可以分为四个状态: 1.创建状态: 当用new操作符创建一个新的线程对象时,该线程处于创建状态. 处于创建状态的线程只是一个空的线程对象,系统不为它分配资源. 2.可运行状态: 执行线程的start()方法将为线程分配必须的系统资源,安排其运行,并调用线程体——run()方法,这样就使得该线程处于可运行状态(Runnable). 这一

Java多线程开启三个线程输出ABC10次

最近学多线程,搜了一下,满屏幕的问题都是类似标题那样的,所以就拿这个当开始吧,自己试了一下手, 多次把电脑CPU跑到100%,终于还是写出来了,大体思路为: 声明一个变量,标记三个线程该哪个线程输出,每次输出将该变量+1,判断方式为 变量对3的余数,如果为1-A,2-B, 3-C 1 public class ABC { 2 3 private static int mark = 0; 4 5 private static Object obj = new Object(); 6 7 publi

多线程(三)线程同步

一:线程同步 当多个线程共享数据时就会发生安全性问题,而解决这个问题,就需要通过线程同步这个机制来解决. 1.什么是线程同步: 解决数据共享问题,必须使用同步,所谓同步就是指多个线程在同一时间段之内只能有一个线程执行指定代码, 其他线程要等待此线程执行完成之后才可以继续执行. "加锁->修改->释放锁",任何线程在修改指定资源之前,首先对该资源加锁,在加锁期间其他线程无法修改该 资源,当该线程修改完成后,该线程释放对该资源的锁定,通过这种方式就可以保证并发线程在任一时刻只有

UNIX环境编程学习笔记(28)——多线程编程(三):线程的取消

lienhua342014-11-24 1 取消线程 pthread 提供了pthread_cancel 函数用于请求取消同一进程中的其他线程. #include <pthread.h> int pthread_cancel(pthread_t tid); 返回值:若成功则返回0,否则返回错误编码 pthread_cancel 调用并不会立即终止目标线程,而只是向目标线程发出取消请求.调用线程不等待目标线程终止,在默认情况下,目标线程在取消请求发出以后还是继续运行的,直到目标线程到达某个取消点

多线程(三)-- 线程安全问题

安全解决 -- 互斥锁@synchronized(self) { //开始加锁,操作} 优:解决多线程抢夺资源产生的数据安全问题缺:消耗CPU资源多 使用前提:多条线程执行一块代码时加锁 线程同步:@synchronized()多条线程在同一条线上执行(按顺序执行,与线程并发不同) nonatomic 与 atomicatomic保护线程安全,自动加锁为setter加锁 对比atomic:线程安全,消耗大量资源nonatomic:非线程安全,适合内存小的移动设备

Java多线程系列四——控制线程执行顺序

假设有线程1/线程2/线程3,线程3必须在线程1/线程2执行完成之后开始执行,有两种方式可实现 Thread类的join方法:使宿主线程阻塞指定时间或者直到寄生线程执行完毕 CountDownLatch类:指定计数器,当计数器清零即取消阻塞 import java.util.concurrent.CountDownLatch; import org.junit.Assert; import org.junit.Test; /** * @Description: 规定线程次序的方法 */ publ

多线程(三、线程池原理)

背景 阿里电面-线程池是如何实现的?这个问题的侧重点是什么? 普通的数据库连接池的概念一般是这样的,多个被静态代理或者动态代理生成的数据库连接,直接放到一个池子里,比方说一个队列,这个数据库连接池提供了如下的方法: 这是典型的池化的思想. Java的线程池则不是这个池化的思想 Java的线程池是生产者-消费者模式. ThreadPoolExecutor的构造函数很复杂,它的7个参数分别如下: ThreadPoolExecutor(int corePoolSize, int maximumPool

Java 多线程(八) 线程状态图

结合多线程的学习过程,介绍线程的状态图,随着学习的深入,这幅图不断加入新的内容. 一.线程基本状态图 这幅图是在Java 多线程(三) 线程的生命周期及优先级出现过的: 图中是线程运行的基本状态:线程调用start()方法开始后,就进入到可运行状态,随着CPU的资源调度在运行和可运行之间切换:遇到阻塞则进入阻塞状态. 二.加入同步的线程状态图 多线程的同步机制,及synchronized关键字的使用学习: Java 多线程(五) 多线程的同步 Java 多线程(六) synchronized关键

Java多线程:用三个线程控制循环输出10次ABC

题目:有A,B,C三个线程, A线程输出A, B线程输出B, C线程输出C,要求, 同时启动三个线程, 按顺序输出ABC, 循环10次. 解题思路:要按顺序输出ABC, 循环10次,就要控制三个线程同步工作,也就是说要让三个线程轮流输出,直到10个ABC全部输出则结束线程.这里用一个Lock对象来控制三个线程的同步.用一个int型变量state标识由那个线程输出. 1 package com.thread; 2 3 import java.util.concurrent.locks.Lock;