线程通信的四种方式

Posted 2023-03-30 我是哎呀呀

多个线程在并发执行的时候，他们在CPU中是随机切换执行的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式：

• 通过 volatile 关键字
• 通过 Object类的 wait/notify 方法
• 通过 condition 的 await/signal 方法
• 通过 join 的方式

现在有一个问题，两个线程分别打印字符串，但是当线程A每输出两次的时候，线程B就输出一次，如此反复10次。

通过 volatile 关键字

通过 volatile 关键字来实现这个任务，这个也是最简单的一种实现方式，大致思路 volatile 是共享内存的，两个线程共享一个标志位，当标志位更改的时候就执行不同的线程。

public class VolatileDemo 
    private static volatile boolean flag = true;  //定义一个标志位，当标志位更改的时候不同的线程被执行

    public static void main(String[] args) 
        //线程A启动
        new Thread(() -> 
            int i = 0;
            while(true)  //进行死循环，一直输出语句
                if (flag)  //对标志位的判断，符合就执行
                    System.out.println(Thread.currentThread().getName()+" ===>" + ++i); //输出语句
                    if (i%2==0)  //如果语句输出两次了 改变标志位
                        flag  =false;
                    
                    if (i == 10) break;  //到达十次，结束循环
                
            
        , "A").start();
        new Thread(() -> 
            int i = 0;
            while(true)
                if (!flag)  //判断条件不一样
                    System.out.println(Thread.currentThread().getName()+" 被唤醒啦 " + ++i);
                    flag  = true;  //改变标志位
                    if (i == 5) break;
                
            
        , "B").start();
    

我们发现我们这个位置用的while循环的，用for循环指定次数可以吗，是不可以的，因为我们只是改变了标志位，但是并没有立刻唤醒另外一个线程让他执行，虽然我打印的语句是我被唤醒了，但是实际上只是线程A处于死循环，啥子也不做，直到线程B抢到了时间片，进行对标志位的判断，然后输出语句，在进行空循环，等待A抢到时间片，如此反复，可以自己在if判断外面加一条计数语句，来验证一下结果，如果想要立刻唤醒的话，那么就是另外一种方法啦。

通过 Object类的 wait/notify 方法

对于上面的volatile关键字这个方法来说，我们的线程执行了很多次空循环，来等待另外一个线程来获取锁，这种操作无疑是十分消耗CPU的资源的，所以说为了解决这种情况，我们就需要一种机制可以实现线程之间的通信，可以唤醒其他的线程，而不是等待直到自己获取CPU的时间片，我们都知道，Object类提供了三个线程间通信的方法，wait()，notify()，notifyAll()。这三个方法必须都在同步代码块中执行的。

方法名	具体操作
wait()	wait()方法执行前，是必须要获得对应的锁的，当执行wait()方法后，线程就会释放掉自己所占有的锁，释放CPU，然后进入阻塞状态，直到被notify()方法唤醒。
notify()	会唤醒一个处于等待该对象锁的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。
notifyAll()	和notify()方法差不多，只不过他是唤醒所有等待该对象锁的线程，让他们进入就绪队列，但是谁执行就看谁抢占到CPU，notify()方法也是这样，只不过是唤醒随机的一个而已

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了已就绪（将要竞争锁）的线程，阻塞队列存储了被阻塞的线程。当一个阻塞线程被唤醒后，才会进入就绪队列，进而等待CPU的调度；反之，当一个线程被wait后，就会进入阻塞队列，等待被唤醒。

public class WaitAndNotify 
    public static void main(String[] args) 
        Object lock = new Object();  //创建一个锁对象
        new Thread(() -> 
            for (int i = 1; i <= 10; i++) 
                synchronized (lock)   //首先需要获取锁
                    System.out.println(Thread.currentThread().getName() + " ==> " + i);
                    if (i % 2 == 0) 
                        lock.notify();  //唤醒线程B
                        if (i!=10)
                            try 
                                lock.wait();  //让自己等待
                             catch (InterruptedException e) 
                                e.printStackTrace();
                            
                        
                    
                
            
        , "A").start();
        new Thread(() -> 
            for (int i = 1; i <= 5; i++) 
                synchronized (lock) 
                    lock.notify();  //我们看到，执行notify方法时，后面的代码还是执行了，并不是立刻释放资源
                    System.out.println(Thread.currentThread().getName() + "我执行了notify方法 " + i);
                    if (i!=5)
                        try 
                            lock.wait();
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    
                
            
        , "B").start();
    

好的，通过上面的代码我们发现，当执行notify方法时，我们并不会立刻释放锁资源，而是在执行完我们代码块里面的内容时才会释放掉锁资源，而wait()方法则会立刻释放掉锁资源，进入阻塞状态，这里我们有举例子，可以自己在wait()方法后面加上一个输出语句。我们进行交替通信的规则就是，执行wait(）方法，释放掉锁资源，然后执行 notify() 方法，唤醒其他的线程，在代码中，我在wait()方法上加了一个判断，如果是最后一次的话，那么我就不执行，为什么，因为我在执行wait()方法的时候，那么线程除非被唤醒，否则就会一直阻塞，这样的话我们的demo就不可以结束了，一直处于允许状态。

通过 condition 的 await/signal 方法

Condiction对象是通过lock对象来创建得(调用lock对象的newCondition()方法)，他在使用前也是需要获取锁得，其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。Condiction对象得常用方法：

• await() : 线程自主释放锁，进入沉睡状态，直到被再次唤醒。
• await(long time, TimeUnit unit) ：线程自主释放锁，进入沉睡状态，被唤醒或者未到达等待时间时一直处于等待状态。
• signal()： 唤醒一个等待线程。
• signal()All() ：唤醒所有等待线程,能够从等待方法返回的线程必须获得与Condition相关的锁。

    public static void main(String[] args) 
        //设置一个锁
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        AtomicInteger number = new AtomicInteger(1);
        AtomicInteger count = new AtomicInteger(1);
        new Thread(()->
            while (count.get() != 10)
                lock.lock();
                try 
                    count.getAndIncrement();
                    if (number.get() != 1 && count.get() != 11)
                        condition.await();
                    
                    number.getAndIncrement();
                    System.out.println(Thread.currentThread().getName() + "---> 生产");
                    condition.signalAll();
                catch (Exception e)
                    e.printStackTrace();
                finally 
                    lock.unlock();
                
            
        ,"producter").start();
        new Thread(()->
            while (count.get() != 10 )
                lock.lock();
                try 
                    count.getAndIncrement();
                    if (number.get() != 2 && count.get() != 11)
                        condition.await();
                    
                    number.getAndDecrement();
                    System.out.println(Thread.currentThread().getName() + "---> 消费");
                    condition.signalAll();
                catch (Exception e)
                    e.printStackTrace();
                finally 
                    lock.unlock();
                
            
        ,"customer").start();
    

await操作会立刻释放掉锁，进入阻塞状态，singal会唤醒等待队列中的头节点(失败就依次唤醒)。这个代码逻辑有大问题，只是这样写看得出数据之间的交换即可。注意点：代码一定要在lock和unlock之间。

通过 join 方法来实现线程通信

    public static void main(String[] args) throws InterruptedException 
        Thread A = new Thread(() -> 
            System.out.println("执行完毕");
        ,"A");
        Thread B = new Thread(()->
            try 
                Thread.sleep(1000L);
                System.out.println(Thread.currentThread().getName() + "测试join");
             catch (InterruptedException e) 
                e.printStackTrace();
            
            ,"B");
        A.start();
        B.start();
        B.join();
        System.out.println("Main线程");
    

简单来说，就是join方法会让自己提前执行，比如上面的例子中就是让Main线程阻塞了，等待B线程执行完毕后才会执行。本质就是调用了wait方法，让当前线程阻塞，直到另一个线程执行完毕。(当前线程wait后，执行join方法的线程大概率抢到锁资源，而且当一个线程执行完毕后，会默认调用notifyAll方法。)

小结

其实准确来说，应该只有三种可以通信的方式，join只是让当前线程先执行完，并没有说根据两个线程之间数据的共享。而且这个写的太粗糙了，每一个里面其实还有很多其他的内容，比如AQS队列，volatile关键字等，懒是无敌的，感谢mmmmmm？额的评论，让我想起了这个还没写完，拖了巨久。

android线程间通信的四种实现方式

通过Handler机制.

private void one() {
handler=new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case 123:
tv.setText(""+msg.obj);
break;
}
}
};
new Thread(){
@Override
public void run() {
super.run();
for (int i=0;i<3;i++){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Message message=new Message();
message.what=123;
message.obj="通过Handler机制";
handler.sendMessage(message);
}
}.run();
}
主线程中定义Handler,子线程发消息，通知Handler完成UI更新,Handler对象必须定义在主线程中，如果是多个类直接互相调用，就不是很方便，需要传递content对象或通过接口调用。另外Handler机制与Activity生命周期不一致的原因，容易导致内存泄漏，不推荐使用。

2，runOnUiThread方法

private void two(){
new Thread(){
@Override
public void run() {
super.run();
for (int i=0;i<3;i++){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
runOnUiThread(new Runnable() {
@Override
public void run() {
tv.setText("通过runOnUiThread方法");
}
});
}
}.run();
}
用Activity对象的runOnUiThread方法更新，在子线程中通过runOnUiThread()方法更新UI，强烈推荐使用。
3，View.post(Runnable r) 、

private void three(){
new Thread(){
@Override
public void run() {
super.run();
for (int i=0;i<3;i++){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
tv.post(new Runnable() {
@Override
public void run() {
tv.setText("通过View.post(Runnable r) 方法");
}
});
}
}.run();
}
这种方法更简单，但需要传递要更新的View过去,推荐使用

4，AsyncTask
private void four(){
new MyAsyncTask().execute("通过AsyncTask方法");
}
private class MyAsyncTask extends AsyncTask{
@Override
protected Object doInBackground(Object[] objects) {
for (int i=0;i<3;i++){
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return objects[0].toString();
}
@Override
protected void onPostExecute(Object o) {
super.onPostExecute(o);
tv.setText(o.toString());
}
}

————————————————
版权声明：本文为CSDN博主「流星雨在线」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/liuxingyuzaixian/article/details/78893392