Java

java 线程之间是如何通信的

2020-01-19  本文已影响0人  shengjk1

java线程之间的通信方式总共有 8 种,分别是
volatile、synchronized、interrupt、wait、notify、notifyAll、join、管道输入/输出
我们一个一个的来说明!

  1. volatile



    线程会将内存中的数据,拷贝到各自的本地内存中( 这里的本地内存指的是 cpu cache ( 比如 CPU 的一级缓存、二级缓存等 ),寄存器)。当某个变量被 volatile 修饰并且发生改变时,volatile 变量底层会通过 lock前缀的指令,将该变量写会主存,同时利用 缓存一致性协议,促使其他线程的本地变量的数据无效,从而再次直接从主存读取数据。

代码演示:
java 如何优雅的停止一个线程

2.synchronized



monitor可以理解为一个同步工具,成功则获得了对象的锁,失败,则进入同步队列进行等待

代码演示:
java 如何优雅的停止一个线程

  1. interrupt
    代码演示:
    java 如何优雅的停止一个线程

  2. wait、notify、notifyAll
    代码演示:

/**
 * @author shengjk1
 * @date 2019/8/29
 */

/*
等待/通知的经典范式
 */
public class WaitNotify {
    static boolean flag = true;
    static Object lock = new Object();
    
    public static void main(String[] args) {
        
        Thread waitThread = new Thread(new Wait(), "WaitThread");
        waitThread.start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        Thread notifyThread = new Thread(new Notify(), "notifyThread");
        notifyThread.start();
    }
    
    static class Wait implements Runnable {
        @Override
        public void run() {
            //加锁,拥有lock的Moitor
            synchronized (lock) {
                while (flag) {
                    try {
                        System.out.println(Thread.currentThread() + " flag is true. waitting@" + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                        //执行wait之后会放弃锁并进入对象的等待队列中,进入等待状态
                        // 当被唤醒后会自动重新获得锁
                        //而sleep就是直接去睡觉不会释放锁
                        /*
                        线程状态由 RUNNING 变为 WAITING,并将当前线程放置到对象的等待队列中
                         */
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread() + " flag is false. running@" + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            }
        }
    }
    
    
    static class Notify implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                //获取lock的锁,然后进行通知,通知是不会释放lock的锁,
                //直到当前线程释放了 lock 后,WaitThread才能从 wait 方法中返回
                System.out.println(Thread.currentThread() + " hold lock. notify@" + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                /*
                使用 nofity() 会更加的高效。需要注意的是,nofity() 在某些情况下却会导致死锁,所以只有在经过精细地设计后,才能使用 nofity()。
                总的来讲,一开始应该总是使用 notifyAll(),只有在发现确实它导致性能问题时,才考虑 notify(),并且对死锁问题给予足够的关注。
                唤醒并一定真得能立刻唤醒,它需要等待调用 notify()或notifyAll() 的线程释放锁之后,等待线程才有机会从 wait() 返回。
                
                notify() 方法将等待队列中的一个等待线程从等待队列中移到同步队列中,而 notifyAll() 方法则是将等待队列中所有线程全部移动到同步对象。
                被移动的线程状态由 WAITING 变为 BLOCKED
                 */
                flag = false;
                lock.notifyAll();
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                }
            }
            
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock. notify@" + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                try {
                    //而sleep就是直接去睡觉不会释放锁
                    //所以 lock.wait() 想要 re-obtain ownership of the monitor and resumes execution
                    // 必须等待 睡眠结束
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
  1. join
    代码演示:
/*
如果一个线程 A 执行了 thread.join 语句,其含义是 当前线程 A 等待 thread 线程终止后才从 thread.join 返回
这里涉及了 等待/通知 机制( 等待前驱线程结束,接受前驱线程结束通知 )
 */
public class Join {
    public static void main(String[] args) {
        Thread previout = Thread.currentThread();
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(new Domino(previout), String.valueOf(i));
            thread.start();
            previout = thread;
        }
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " terminate");
    }
    
    static class Domino implements Runnable {
        private Thread thread;
        
        public Domino(Thread thread) {
            this.thread = thread;
        }
        
        @Override
        public void run() {
            try {
                //join线程终止后,线程的 this.notifyAll() 方法会被调用
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " terminate.");
        }
    }
}
  1. 管道输入/输出
    代码演示:
//管道输入/输出流,主要用于线程之间的数据传输,而传输的媒介是内存
public class Piped {
    public static void main(String[] args) throws IOException {
        PipedWriter out = new PipedWriter();
        PipedReader in = new PipedReader();
        //将 writer 的数据写入 reader 里面
        out.connect(in);
        
        //当没有数据过来时,相当于object.wait()
        Thread printThread = new Thread(new Print(in), "PrintThread");
        printThread.start();
        int receive = 0;
        try {
            while ((receive = System.in.read()) != -1) {
                out.write(receive);
                System.out.println("out====== " + receive);
            }
        } finally {
            out.close();
        }
    }
    
    
    static class Print implements Runnable {
        private PipedReader in;
        
        //PipedReader 传进来
        public Print(PipedReader in) {
            this.in = in;
        }
        
        @Override
        public void run() {
            int receive = 0;
            try {
                while ((receive = in.read()) != -1) {
                    System.out.println("receive===== " + receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

参考:
java并发编程的艺术

上一篇 下一篇

猜你喜欢

热点阅读