Java线程间的通信

Java线程间的通信

锁与同步

在Java中，锁的概念是基于对象的，所以我们又称为对象锁。线程与锁的关系，我们可以使用婚姻关系来理解，一个锁同一时间只能被一个线程持有，那其他线程如果需要得到这个锁，就得等这个线程释放这个锁

线程之间，有一个同步的概念：线程同步是线程之间按照一定的顺序执行。为了达到线程同步，我们可以使用锁来实现它

首先有一个无锁的示例

public class NoneLock {
static class ThreadA implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread A " + i);
        }
    }
}

static class ThreadB implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("Thread B " + i);
        }
    }
}

public static void main(String[] args) {
    new Thread(new ThreadA()).start();
    new Thread(new ThreadB()).start();
}

}

可以看到线程A和线程B各自独自工作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-50zNNoMF-1638712713079)(C:\Users\Leoyu\AppData\Roaming\Typora\typora-user-images\image-20211202105239627.png)]

那么如果我想线程A先执行完，再执行B的最简单办法就是加锁

声明一个lock的对象锁。在线程A，B需要同步的代码块里，都是用synchronized关键字加上了同一个对象锁lock

等待/通知机制

上面一种基于锁的方式，线程需要不断地去尝试获取锁，如果失败了，再继续尝试，这可能会耗费服务器资源。

而等待/通知是另一种方式

Java多线程的等待/通知机制是基于Object类的wait()方法和notify()，notifyAll()方法来实现的

notify方法会随机叫醒一个正在等待的线程，notifyAll()会叫醒所有正在等待的线程

那么我们可以这样处理，假如线程A现在持有了一个锁lock并开始执行，它可以使用lock.wait()让自己进入等待状态，这个时候，lock这个锁是被释放了的。

这时，线程B获得这个锁并开始执行，它可以在某一时刻，使用lock.notify()，通知线程A

这个时候线程B并没有释放锁，除非线程B这个时候使用lock.wait()释放锁，或者线程B执行结束自行释放锁，线程A才能得到锁

public class WaitAndNotify {
    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadA: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadB: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new WaitAndNotify.ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new WaitAndNotify.ThreadB()).start();
    }
}

线程A和线程B首先打印出自己需要的东西，然后使用notify()方法叫醒另一个正在等待的线程，然后自己使用wait()方法陷入等待并释放lock锁。

等待/通知机制使用的是使用同一个对象锁，如果你两个线程使用的是不同的对象锁，那它们之间是不能用等待/通知机制通信的。

信号量

JDK提供了一个类似于“信号量”功能的类Semaphore。

A，B线程交替输出数字

public class Signal {
private static volatile int signal = 0;

static class ThreadA implements Runnable {
    @Override
    public void run() {
        while (signal < 5) {
            if (signal % 2 == 0) {
                System.out.println("threadA: " + signal);
                signal++;
            }
        }
    }
}

static class ThreadB implements Runnable {
    @Override
    public void run() {
        while (signal < 5) {
            if (signal % 2 == 1) {
                System.out.println("threadB: " + signal);
                signal = signal + 1;
            }
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    new Thread(new ThreadA()).start();
    Thread.sleep(1000);
    new Thread(new ThreadB()).start();
}

}

// 输出：
threadA: 0
threadB: 1
threadA: 2
threadB: 3
threadA: 4

这里使用了一个volatile变量signal来实现了“信号量”模型。volatile变量需要进行原子操作

信号量的应用场景

假如在一个停车场中，车位是我们的公共资源，线程就如同车辆，而看门的管理员就是起的“信号量”的作用

因为在这种场景下，多个线程需要互相合作，我们用简单的锁和等待通知机制不是那么方便，这时候就可以用到信号量

管道

管道是基于管道流的通信方式。JDK提供了PipedWriter，PipedReader，PipedOutPutStream，PipedInputStream。其中，前面两个是基于字符的，后面两个是基于字节流的

其他通信相关

join方法

join()方法是Thread类的一个实例方法。它的作用是让当前线程陷入“等待”状态，等join的这个线程执行完成后，再继续执行当前线程

有时候，主线程创建并启动了子线程，如果子线程中需要进行大量的耗时计算，主线程往往早于子线程结束之前结束，如果主线程想等待子线程执行完毕后，获得子线程中的处理完的某个数据，就要用到join方法了

public class Join {
static class ThreadA implements Runnable {

    @Override
    public void run() {
        try {
            System.out.println("我是子线程，我先睡一秒");
            Thread.sleep(1000);
            System.out.println("我是子线程，我睡完了一秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new ThreadA());
    thread.start();
    thread.join();
    System.out.println("如果不加join方法，我会先被打出来，加了就不一样了");
}

}

注意join()方法有两个重载方法，一个是join(long)，一个是join(long,int)。

join()方法及其重载方法底层都是利用wait(long)这个方法

sleep方法

sleep方法是Thread类的一个静态方法。它的作用是让当前线程睡眠一段时间，有两个方法：

• Thread.sleep(long)
• Thread.sleep(long,int)

sleep方法是不会释放当前锁的，而wait方法会

区别：

• wait可以指定时间，也可以不指定；而sleep必须指定时间
• wait释放cpu资源，同时释放锁；sleep释放cpu资源，但是不释放锁，所以易死锁
• wait必须放在同步块或同步方法中，而sleep可以在任意位置

ThreadLocal类

ThreadLocal是一个本地线程副本变量工具类，内部是一个弱引用的Map来维护

ThreadLocal类并不属于多线程间的通信，而是让每个线程有自己"独立"的变量，线程互相间不影响。它为每个线程都创建一个副本，每个线程可以访问自己内部的副本变量

如果开发者希望类的某个静态变量与线程状态关联，则可以考虑使用ThreadLocal

最常见的ThreadLocal使用场景为用来解决数据库连接，Session管理等。数据库连接和Session管理涉及多个复杂对象的初始化和关闭。如果在每个线程中声明一些私有变量来进行操作，那这个线程就变得不那么“轻量”了，需要频繁的创建和关闭连接

InheritableThreadLocal

Inheritable是继承的意思。它不仅仅是当前线程可以存取副本值，而且它的子线程也可以存取这个副本值