Java线程(12)：线程间通信

线程中断

thread的方法，线程中断涉及到三个方法，如下：

  1. void interrupt(): 中断线程
  2. static boolean interrupted(): 测试当前线程是否已经中断
  3. boolean isInterrupted(): 测试线程是否已经中断
1. interrupt()方法用于中断线程，通常的理解来看，只要某个线程启动后，调用了该方法，则该线程不能继续执行了，来看个小例子：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public class InterruptTest {  
    public static void main(String[] args) throws InterruptedException {  
        MyThread t = new MyThread("MyThread");  
        t.start();  
        Thread.sleep(100);// 睡眠100毫秒  
        t.interrupt();// 中断t线程  
    }  
}  
class MyThread extends Thread {  
    int i = 0;  
    public MyThread(String name) {  
        super(name);  
    }  
    public void run() {  
        while(true) {// 死循环，等待被中断  
            System.out.println(getName() + getId() + "执行了" + ++i + "次");  
        }  
    }  
}
    
运行后，我们发现，线程t一直在执行，没有被中断，原来`interrupt()`是骗人的，汗！其实`interrupt()`方法并不是中断线程的执行，而是为调用该方法的线程对象打上一个标记，设置其中断状态为`true`，
通过`isInterrupted()`方法可以得到这个线程状态，我们将上面的程序做一个小改动：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public class InterruptTest {  
    public static void main(String[] args) throws InterruptedException {  
        MyThread t = new MyThread("MyThread");  
        t.start();  
        Thread.sleep(100);// 睡眠100毫秒  
        t.interrupt();// 中断t线程  
    }  
}  
class MyThread extends Thread {  
    int i = 0;  
    public MyThread(String name) {  
        super(name);  
    }  
    public void run() {  
        while(!isInterrupted()) {// 当前线程没有被中断，则执行  
            System.out.println(getName() + getId() + "执行了" + ++i + "次");  
        }  
    }  
}

这样的话，线程被顺利的中断执行了。很多人实现一个线程类时，都会再加一个flag标记，以便控制线程停止执行，其实完全没必要，通过线程自身的中断状态，就可以完美实现该功能。

如果线程在调用Object类的wait()、wait(long)或wait(long, int)方法，或者该类的join()、join(long)、join(long, int)、sleep(long)或sleep(long, int)方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。

我们可以捕获该异常，并且做一些处理。另外，Thread.interrupted()方法是一个静态方法，它是判断当前线程的中断状态，需要注意的是，线程的中断状态会由该方法清除。

换句话说，如果连续两次调用该方法，则第二次调用将返回false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

线程让步

线程让步，其方法如下：

  1. static void yield(): 暂停当前正在执行的线程对象，并执行其他线程

线程让步用于正在执行的线程，在某些情况下让出CPU资源，让给其它线程执行，来看一个小例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
public class YieldTest {  
    public static void main(String[] args) throws InterruptedException {  
        // 创建线程对象  
        YieldThread t1 = new YieldThread("t1");  
        YieldThread t2 = new YieldThread("t2");  
        // 启动线程  
        t1.start();  
        t2.start();  
        // 主线程休眠100毫秒  
        Thread.sleep(100);  
        // 终止线程  
        t1.interrupt();  
        t2.interrupt();  
    }  
}  
class YieldThread extends Thread {  
    int i = 0;  
    public YieldThread(String name) {  
        super(name);  
    }  
    public void run() {  
        while(!isInterrupted()) {  
            System.out.println(getName() + "执行了" + ++i + "次");  
            if(i % 10 == 0) {// 当i能对10整除时，则让步  
                Thread.yield();  
            }  
        }  
    }  
}

 

输出结果略，从输出结果可以看到，当某个线程(t1或者t2)执行到10次、20次、30次等时，就会马上切换到另一个线程执行，接下来再交替执行，如此往复。

注意，如果存在synchronized线程同步的话，线程让步不会释放锁(监视器对象)。

线程睡眠

线程睡眠涉及到两个方法，如下：

  1. static void sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。
  2. static void sleep(long millis, int nanos): 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行）。

线程睡眠的过程中，如果是在·synchronized·线程同步内，是持有锁(监视器对象)的，也就是说，线程是关门睡觉的，别的线程进不来，来看一个小例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
public class SleepTest {  
    public static void main(String[] args) {  
        // 创建共享对象  
        Service service = new Service();  
        // 创建线程  
        SleepThread t1 = new SleepThread("t1", service);  
        SleepThread t2 = new SleepThread("t2", service);  
        // 启动线程  
        t1.start();  
        t2.start();  
    }  
      
}  
class SleepThread extends Thread {  
    private Service service;  
    public SleepThread(String name, Service service) {  
        super(name);  
        this.service = service;  
    }  
    public void run() {  
        service.calc();  
    }  
}  
class Service {  
    public synchronized void calc() {  
        System.out.println(Thread.currentThread().getName() + "准备计算");  
        System.out.println(Thread.currentThread().getName() + "感觉累了，开始睡觉");  
        try {  
            Thread.sleep(10000);// 睡10秒  
        } catch (InterruptedException e) {  
            return;  
        }  
        System.out.println(Thread.currentThread().getName() + "睡醒了，开始计算");  
        System.out.println(Thread.currentThread().getName() + "计算完成");  
    }  
}

 

输出结果：

1
2
3
4
5
6
7
8
9
 
[java] view plain copy print?
t1准备计算  
t1感觉累了，开始睡觉  
t1睡醒了，开始计算  
t1计算完成  
t2准备计算  
t2感觉累了，开始睡觉  
t2睡醒了，开始计算  
t2计算完成

 

线程合并

线程合并涉及到三个方法，如下：

  1. void join(): 等待该线程终止。
  2. void join(long millis): 等待该线程终止的时间最长为millis毫秒。
  3. void join(long millis, int nanos): 等待该线程终止的时间最长为millis毫秒 + nanos纳秒。

 

总结
首先join() 是一个synchronized方法， 里面调用了wait()，这个过程的目的是让持有这个同步锁的线程进入等待，那么谁持有了这个同步锁呢？

答案是主线程，因为主线程调用了threadA.join()方法，相当于在threadA.join()代码这块写了一个同步代码块，谁去执行了这段代码呢，是主线程，所以主线程被wait()了。

然后在子线程threadA执行完毕之后，JVM会调用lock.notify_all(thread);唤醒持有threadA这个对象锁的线程，也就是主线程，会继续执行。

线程合并是优先执行调用该方法的线程，再执行当前线程，来看一个小例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public class JoinTest {  
    public static void main(String[] args) throws InterruptedException {  
        JoinThread t1 = new JoinThread("t1");  
        JoinThread t2 = new JoinThread("t2");  
        t1.start();  
        t2.start();  
        t1.join();  
　　　　 System.out.println("主线程执行了!");
        t2.join();  
        System.out.println("主线程开始执行！");  
    }  
}  
class JoinThread extends Thread {  
    public JoinThread(String name) {  
        super(name);  
    }  
    public void run() {  
        for(int i = 1; i <= 10; i++)  
            System.out.println(getName() + getId() + "执行了" + i + "次");  
    }  
}

 

t1和t2都执行完才继续主线程的执行，所谓合并，就是等待其它线程执行完，再执行当前线程，执行起来的效果就好像把其它线程合并到当前线程执行一样。

t111执行了1次
t212执行了1次
t111执行了2次
t111执行了3次
t111执行了4次
t111执行了5次
t212执行了2次
t111执行了6次
t111执行了7次
t111执行了8次
t111执行了9次
t111执行了10次
执行了主线程
t212执行了3次
t212执行了4次
t212执行了5次
t212执行了6次
t212执行了7次
t212执行了8次
t212执行了9次
t212执行了10次
主线程开始执行！

线程优先级

线程最低优先级为1，最高优先级为10，看起来就有10个级别，但这10个级别能不能和CPU对应上，还未可知，Thread类中提供了优先级的三个常量，如下：

1
2
3
 
public static final int	MAX_PRIORITY = 10;
public static final int	MIN_PRIORITY = 1;
public static final int	NORM_PRIORITY = 5;

 

我们创建线程对象后，如果不显示的设置优先级的话，默认为5。优先级可以看成一种特权，优先级高的，获取CPU调度的机会就大，优先级低的，获取CPU调度的机会就小，

这个和我们现实生活很一样啊，优胜劣汰。线程优先级的示例就不写了，比较简单。

wait()和sleep()区别

区别太大了，但是在Java线程面试题中是很常见的问题，相信你阅读过本专栏后，能够轻松的解答，这里不再赘述。

 

总结：

1.sleep：Thread类的方法，必须带一个时间参数。会让当前线程休眠进入阻塞状态并释放CPU（阿里面试题 Sleep释放CPU，wait呢），

提供其他线程运行的机会且不考虑优先级，但如果有同步锁则sleep不会释放锁即其他线程无法获得同步锁

2.yield：让出CPU调度，Thread类的方法，类似sleep只是不能由用户指定暂停多长时间 ，并且yield()方法只能让同优先级的线程有执行的机会。 

yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

调用yield方法只是一个建议，告诉线程调度器我的工作已经做的差不多了，可以让别的相同优先级的线程使用CPU了，没有任何机制保证采纳。

3.wait：Object类的方法(notify()、notifyAll()  也是Object对象)，必须放在循环体和同步代码块中，执行该方法的线程会释放锁，进入线程等待池中等待被再次唤醒(notify随机唤醒，

notifyAll全部唤醒，线程结束自动唤醒)即放入锁池中竞争同步锁

4.join：Thread类的方法，一种特殊的wait，当前运行线程调用另一个线程的join方法，当前线程进入阻塞状态直到另一个线程运行结束等待该线程终止。 注意该方法也需要捕捉异常。

 

 

接近一周没更新《Java线程》专栏了，主要是这周工作上比较忙，生活上也比较忙，呵呵，进入正题，上一篇讲述了并发包下的Lock，Lock可以更好的解决线程同步问题，使之更面向对象，并且ReadWriteLock在处理同步时更强大，那么同样，线程间仅仅互斥是不够的，还需要通信，本篇的内容是基于上篇之上，使用Lock如何处理线程通信。

那么引入本篇的主角，Condition，Condition将Object监视器方法（wait、notify和notifyAll）分解成截然不同的对象，以便通过将这些对象与任意Lock实现组合使用，为每个对象提供多个等待set（wait-set）。其中，Lock替代了synchronized方法和语句的使用，Condition替代了Object监视器方法的使用。下面将之前写过的一个线程通信的例子替换成用Condition实现(Java线程(三))，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
public class ThreadTest2 {
    public static void main(String[] args) {
        final Business business = new Business();
        new Thread(() -> {
            threadExecute(business, "sub");
        }).start();
        threadExecute(business, "main");
    }

    public static void threadExecute(Business business, String threadType) {
        for (int i = 0; i < 100; i++) {
            try {
                if ("main".equals(threadType)) {
                    business.main(i);
                }
                else {
                    business.sub(i);
                }
            }
            catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Business {
    private boolean bool = true;

    private Lock lock = new ReentrantLock();

    private Condition condition = lock.newCondition();

    public /* synchronized */ void main(int loop) throws InterruptedException {
        lock.lock();
        try {
            while (bool) {
                condition.await();// this.wait();
            }
            for (int i = 0; i < 100; i++) {
                System.out.println("main thread seq of " + i + ", loop of " + loop);
            }
            bool = true;
            condition.signal();// this.notify();
        }
        finally {
            lock.unlock();
        }
    }

    public /* synchronized */ void sub(int loop) throws InterruptedException {
        lock.lock();
        try {
            while (!bool) {
                condition.await();// this.wait();
            }
            for (int i = 0; i < 10; i++) {
                System.out.println("sub thread seq of " + i + ", loop of " + loop);
            }
            bool = false;
            condition.signal();// this.notify();
        }
        finally {
            lock.unlock();
        }
    }
}

在Condition中，用await()替换wait()，用signal()替换notify()，用signalAll()替换notifyAll()，传统线程的通信方式，Condition都可以实现，这里注意，Condition是被绑定到Lock上的，要创建一个Lock的Condition必须用newCondition()方法。
这样看来，Condition和传统的线程通信没什么区别，Condition的强大之处在于它可以为多个线程间建立不同的Condition，下面引入API中的一段代码，加以说明。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
class BoundedBuffer {  
   final Lock lock = new ReentrantLock();//锁对象  
   final Condition notFull  = lock.newCondition();//写线程条件   
   final Condition notEmpty = lock.newCondition();//读线程条件   
  
   final Object[] items = new Object[100];//缓存队列  
   int putptr/*写索引*/, takeptr/*读索引*/, count/*队列中存在的数据个数*/;  
  
   public void put(Object x) throws InterruptedException {  
     lock.lock();  
     try {  
       while (count == items.length)//如果队列满了   
         notFull.await();//阻塞写线程  
       items[putptr] = x;//赋值   
       if (++putptr == items.length) putptr = 0;//如果写索引写到队列的最后一个位置了，那么置为0  
       ++count;//个数++  
       notEmpty.signal();//唤醒读线程  
     } finally {  
       lock.unlock();  
     }  
   }  
  
   public Object take() throws InterruptedException {  
     lock.lock();  
     try {  
       while (count == 0)//如果队列为空  
         notEmpty.await();//阻塞读线程  
       Object x = items[takeptr];//取值   
       if (++takeptr == items.length) takeptr = 0;//如果读索引读到队列的最后一个位置了，那么置为0  
       --count;//个数--  
       notFull.signal();//唤醒写线程  
       return x;  
     } finally {  
       lock.unlock();  
     }  
   }   
 }

这是一个处于多线程工作环境下的缓存区，缓存区提供了两个方法，put和take，put是存数据，take是取数据，内部有个缓存队列，具体变量和方法说明见代码，这个缓存区类实现的功能：有多个线程往里面存数据和从里面取数据，其缓存队列(先进先出后进后出)能缓存的最大数值是100，多个线程间是互斥的，当缓存队列中存储的值达到100时，将写线程阻塞，并唤醒读线程，当缓存队列中存储的值为0时，将读线程阻塞，并唤醒写线程，这也是ArrayBlockingQueue的内部实现。下面分析一下代码的执行过程：

  1. 一个写线程执行，调用put方法；
  2. 判断count是否为100，显然没有100；
  3. 继续执行，存入值；
  4. 判断当前写入的索引位置++后，是否和100相等，相等将写入索引值变为0，并将count+1；
  5. 仅唤醒读线程阻塞队列中的一个；
  6. 一个读线程执行，调用take方法；
  7. ……
  8. 仅唤醒写线程阻塞队列中的一个；

这就是多个Condition的强大之处，假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程，那么假设只有一个Condition会有什么效果呢，缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。

原文作者：文／高爽|Coder（CSDN作者）
原文标题：Java线程(九)：Condition-线程通信更高效的方式

 

 

 

 

 

 

 

posted @ 2019-07-31 16:17  qxwang  阅读(120)  评论(0)    收藏  举报