Java多线程——线程通信

线程通信概念

在多线程任务中，某一个线程的执行结果是另一个线程需要的资源，这样，我们就需要使两个线程的执行顺序做调整，并且使其资源能够流通。

涉及方法

• wait()：一旦执行此方法，使当前线程进入阻塞状态，并释放同步监视器
• notify()：一旦执行此方法，就会唤醒被wait()的一个线程，若有多个线程，则唤醒优先级高的
• notifyAll()：一旦执行此方法，唤醒所有被wait()的线程。

线程通信：使用两个线程交替打印 1~100
class Number implements Runnable{
    private int title=0;
    private Object obj=new Object();
    @Override
    public void run() {
        while(true){

            synchronized (obj) {
                obj.notify();//结束阻塞
                if (title<100) {
                    try {
                        Thread.sleep(100);//不会释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + title++);
//                    进入阻塞
                    try {
                        obj.wait();//释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else break;
            }
        }

    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        Number n1 = new Number();
        Thread t1 = new Thread(n1);
        Thread t2 = new Thread(n1);
        t1.setName("线程一");
        t2.setName("线程二");
        t1.start();
        t2.start();
    }
}

说明：

• 1、wait() notify() notifyAll()这三个方法，必须在同步方法和同步代码块中调用
• 2、wait() notify() notifyAll()这三个方法的调用者必须是同步方法和同步代码块中的同步监视器。
• 否则会报 IllegalMonitorStateException
• 3、wait() notify() notifyAll()这三个方法定义在java.long.object中

sleep与wait 异同
相同：一旦执行方法，都可以使线程进入阻塞状态
不同：
1）声明位置不同：wait() 定义在java.long.object中 sleep定义在Thread类中
2）调用位置要求不同：sleep()可以在任意位置调用，wait()必须在同步方法和同步代码块中调用
3) 是否释放同步监视器：若在同步方法和同步代码块中调用两个方法，sleep（）不会释放同步监视器，wait()反之。

线程死锁

1、死锁的理解：不同的线程分别占用对方需要的同步资源不放弃。都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
2、说明
1）出现死锁之后，不会出现提示，只有所有的线程处于阻塞状态，无法继续。
2）使用同步时，要避免出现死锁。

public class ThreadTest01 {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                 synchronized(s1){
                     s1.append('l');
                     s1.append('a');
                     try {
                         Thread.sleep(100);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     synchronized(s2){
                         s2.append('h');
                         s2.append('a');

                         System.out.println(s1);
                         System.out.println(s2);
                     }
                 }
            }
        }.start();
//        匿名类形式 Runable 接口实现线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(s2){
                    s1.append('m');
                    s1.append('a');
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized(s1){
                        s2.append('n');
                        s2.append('a');

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}