java多线程-Java线程间的通信-5

那山川

已于 2022-11-07 16:24:38 修改

阅读量130

点赞数

分类专栏：多线程文章标签： java jvm 开发语言

于 2022-08-09 18:31:31 首次发布

本文链接：https://blog.csdn.net/weixin_44285713/article/details/126242496

版权

多线程专栏收录该内容

7 篇文章 0 订阅

订阅专栏

锁与同步

在java中锁概念基于对象，常称为对象锁。一个锁同一时间只能被一个线程所持有。就好比只有一个厕所坑位，你要是想进去上厕所必须要等待前面的人出来。

线程之间有一个同步的概念。线程同步即线程之间按照一定顺序执行。先看一个无锁程序。

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

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

执行的部分结果为：

执行过程中线程A与线程B独立工作，每一次运行结果都不同。

现在实现一下先执行A再去执行B，使用一个“对象锁”

public class ObjectLock {
    private static Object lock = new Object();
    static class ThreadA implements Runnable{
        @Override
        public void run() {
            synchronized (lock){
                for (int i = 0; i < 50; i++) {
                    System.out.println("ThreadA"+i);
                }
            }
        }
        static class ThreadB implements Runnable{
            @Override
            public void run() {
                synchronized (lock){
                    for (int i = 0; i < 50; i++) {
                        System.out.println("ThreadB"+i);
                    }
                }
            }
        }

        public static void main(String[] args) throws InterruptedException {
            new Thread(new ThreadA()).start();
            // 线程A、B都是就绪状态，防止操作系统让B先执行，这里休眠10ms
            Thread.sleep(10);
            new Thread(new ThreadB()).start();
        }
    }
}

执行部分结果为：

首先声明了一个lock对象锁，在ThreadA和ThreadB内需要同步的代码块里，都是用synchronized关键字加上了同一个对象锁lock。由于同一时间内只有一个线程持有锁，所以线程B会等待线程A执行完成后释放lock，线程B才能获得锁lock。

等待/通知机制

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

等待/通知机制是另一种方式。

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

由于一个锁同一时刻只能被一个线程持有，假如A线程持有了一个锁lock并开始执行，它可以使用lock.wait()让自己进入等待状态。这个时候lock锁会被释放。此时线程B获得lock锁并执行，它可以在某一个时刻使用lock.notifu()方法，通知之前持有lock锁并进入等待状态的线程A被唤醒，告诉A继续向下执行。

此时锁对象还是在B线程手里，只有B线程调用了lock.wait()或者线程B执行完毕A线程才能得到lock锁。

具体看下代码：

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 < 10; i++) {
                    // 打印"ThreadA: " + i
                    System.out.println("ThreadA: " + i);
                    // 唤醒另一个正在等待的线程
                    lock.notify();
                    try {
                        // 进入等待状态，释放锁
                        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 < 10; i++) {
                    try {
                        // 打印"ThreadB: " + i
                        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 ThreadA()).start();
        // 防止操作系统先让线程B启动
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

执行结果为：

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

信号量

JDK提供了一个类似“信号量”功能的类Semaphore。但是我这里介绍的是基于volatile关键字的自己实现的信号量通信。volatile关键字的一些相关内容我已经发过了。

volatile关键字能够保证内存的可见性，如果用volatile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其它线程是立马可见更改后的值的。

现在实现一个需求：线程A输出0，然后线程B输出1，再然后线程A输出2.......

public class Signal {
    // 使用volatile关键字初始化信号量为0
    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();
    }
}

执行结果为：

需要注意的是volatile变量需要进行原子操作，但是signal++并不是一个原子操作，所以实际开发时需要使用synchronized给它“上锁”或者使用AtomicInteger等原子类，上面的程序是线程不安全的，因为执行while语句后可能当前线程就暂停等待时间片了，等线程醒来，可能signal已经大于等于5了。

管道

管道是基于“管道流”的通信方式。JDK提供了PipedWriter、 PipedReader、 PipedOutputStream、 PipedInputStream

其中，前面两个是基于字符的，后面两个是基于字节流的。这里的示例代码使用的是基于字符的：

public class Pipe {
    static class ReaderThread implements Runnable {
        private PipedReader reader;

        public ReaderThread(PipedReader reader) {
            this.reader = reader;
        }

        @Override
        public void run() {
            System.out.println("this is reader");
            int receive = 0;
            try {
                while ((receive = reader.read()) != -1) {
                    System.out.print((char)receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    static class WriterThread implements Runnable {
        private PipedWriter writer;

        public WriterThread(PipedWriter writer) {
            this.writer = writer;
        }

        @Override
        public void run() {
            System.out.println("this is writer");
            int receive = 0;
            try {
                writer.write("test");
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        // 进行连接才能通信
        writer.connect(reader);
        new Thread(new ReaderThread(reader)).start();
        Thread.sleep(1000);
        new Thread(new WriterThread(writer)).start();
    }
}

执行结果为：

通过线程的构造函数传入了 PipedWrite和PipedReader对象，代码执行流程如下：

1.线程ReaderThread开始执行

2.线程ReaderThread使用管道reader.read()进入”阻塞“

3.线程WriterThread开始执行

4.线程WriterThread用writer.write("test")往管道写入字符串

5.线程WriterThread使用writer.close()结束管道写入，并执行完毕

6.线程ReaderThread接受到管道输出的字符串并打印

7.线程ReaderThread执行完毕

应用场景

使用管道多半与I/O流相关，当我们一个线程需要先另一个线程先发送一个消息或者文件等等时，就需要使用管道通信了。

其它通信相关

join方法

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

有时候主线程创建并启动了子线程，如果子线程中需要大量的耗时运算，主线程往往比子线程先结束，如果主线程想等子线程执行完毕后获得子线程处理完的某个数据，就要用到join()方法。

代码如下：

public class Join {
    static class ThreadA implements Runnable{
        @Override
        public void run() {
            try {
                System.out.println("我是子线程，先睡1s");
                Thread.sleep(1000);
                System.out.println("我是子线程，我睡完1s了");
            } 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)方法

对于join(long, int)，源码中对于第二个参数nanos做了简单的判断和处理，没有精确到纳秒。

sleep方法

sleep()方法是Thread的一个静态方法。他的作用是让线程睡眠一段时间，但是不释放当前锁。它有这样两个方法：

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

同样，查看源码(JDK 1.8)发现，第二个方法貌似只对第二个参数做了简单的处理，没有精确到纳秒。实际上还是调用的第一个方法。

这里需要强调一下：sleep方法是不会释放当前的锁的，而wait方法会。这也是最常见的一个多线程面试题。

它们还有这些区别：

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

ThreadLocal类

ThreadLocal是一个本地线程副本变量工具类，内部是一个弱引用的Map来维护，介绍一下他的作用。ThreadLocal类原理可以看这几篇大神总结的

ThreadLocal原理

有的人称ThreadLocal为线程本地变量或线程本地存储。严格来说，ThreadLocal类并不属于多线程间的通信，而是让每个线程有自己”独立“的变量，线程之间互不影响。它为每个线程都创建一个副本，每个线程可以访问自己内部的副本变量。

ThreadLocal类最常用的就是set方法和get方法。示例代码：

public class ThreadLocalTest {
    static class ThreadA implements Runnable {
        private ThreadLocal<String> threadLocal;

        public ThreadA(ThreadLocal<String> threadLocal) {
            this.threadLocal = threadLocal;
        }

        @Override
        public void run() {
            threadLocal.set("A");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadA输出：" + threadLocal.get());
        }

        static class ThreadB implements Runnable {
            private ThreadLocal<String> threadLocal;

            public ThreadB(ThreadLocal<String> threadLocal) {
                this.threadLocal = threadLocal;
            }

            @Override
            public void run() {
                threadLocal.set("B");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("ThreadB输出：" + threadLocal.get());
            }
        }

        public static void main(String[] args) {
            ThreadLocal<String> local = new ThreadLocal<>();
            new Thread(new ThreadA(local)).start();
            new Thread(new ThreadB(local)).start();
        }
    }
}

执行结果为：

可以看到,虽然两个线程使用的同一个ThreadLocal实例，通过构造方法传入。但是它们各自都可以存取自己当前线程的一个值。

如果只是单纯的想要线程隔离，在每个线程中声明一个私有变量就好了呀,那么ThreadLocal的作用是什么呢？

如果希望将类的某个静态（user ID或者transaction ID）与线程状态关联，则可以考虑使用ThreadLocal。

最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理等。ThreadLocal使用场景为用来解决数据库连接、Session管理等。

InheritableThreadLocal

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

那山川

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
java多线程-Java线程间的通信-5

在java中锁概念基于对象，常称为对象锁。一个锁同一时间只能被一个线程所持有。就好比只有一个厕所坑位，你要是想进去上厕所必须要等待前面的人出来。线程之间有一个同步的概念。线程同步即线程之间按照一定顺序执行。先看一个。执行的部分结果为：执行过程中线程A与线程B独立工作，每一次运行结果都不同。现在实现一下先执行A再去执行B，使用一个“对象锁”执行部分结果为：首先声明了一个lock对象锁，在ThreadA和ThreadB内需要同步的代码块里，都是用关键字加上了同一个对象锁lock。...
复制链接

扫一扫