Java并发编程学习（三）——线程通信

最新推荐文章于 2022-11-03 15:51:51 发布
最新推荐文章于 2022-11-03 15:51:51 发布
阅读量191 收藏 1
点赞数
分类专栏： 读书笔记 文章标签： java 线程 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/amurocrash/article/details/78764055
版权

一、wait and notify

1、先看一个最low的线程通信例子

package com.amuro.studythread.chapter3_communication;

import java.util.ArrayList;
import java.util.List;

public class CommLowestVer
{
    public static void main(String[] args)
    {
        MyList list = new MyList();
        MyThread1 t1 = new MyThread1(list);
        t1.start();
        MyThread2 t2 = new MyThread2(list);
        t2.start();
    }

    static class MyList
    {
        List<String> list = new ArrayList<>();

        void add(String data)
        {
            list.add(data);
        }

        int getSize()
        {
            return list.size();
        }
    }

    static class MyThread1 extends Thread
    {
        MyList list;

        public MyThread1(MyList list)
        {
            this.list = list;
        }

        @Override
        public void run()
        {
            try
            {
                for(int i = 0; i < 100; i++)
                {
                    list.add((i + 1) + "");
                    System.out.println("added");
                    Thread.sleep(500);
                }
            }
            catch(Exception e)
            {

            }
        }
    }

    static class MyThread2 extends Thread
    {
        MyList list;

        public MyThread2(MyList list)
        {
            this.list = list;
        }

        @Override
        public void run()
        {
            while(true)
            {
                if(list.getSize() == 5)
                {
                    System.out.println("stop t2");
                    break;
                }

                System.out.println("t2 run");
            }
        }
    }
}

线程2中的while(true)轮询会严重浪费CPU资源，如果现在几十个，上百个线程都要等待这个结果，这样写代码应该分分钟就会被解雇了……

2、使用wait和notify

package com.amuro.studythread.chapter3_communication;

import java.util.ArrayList;
import java.util.List;

public class CommStandard
{
    public static void main(String[] args) throws Exception
    {
        MyList list = new MyList();

        MyThread2 t2 = new MyThread2(list);
        t2.start();

        Thread.sleep(50);

        MyThread1 t1 = new MyThread1(list);
        t1.start();
    }

    static Object lock = new Object();

    static class MyList
    {
        List<String> list = new ArrayList<>();

        void add(String data)
        {
            list.add(data);
        }

        int getSize()
        {
            return list.size();
        }
    }

    static class MyThread1 extends Thread
    {
        MyList list;

        public MyThread1(MyList list)
        {
            this.list = list;
        }

        @Override
        public void run()
        {
            synchronized (lock)
            {
                try
                {
                    for (int i = 0; i < 10; i++)
                    {
                        list.add((i + 1) + "");
                        System.out.println("added");
                        if (list.getSize() == 5)
                        {
                            System.out.println("t1 notify");
                            lock.notify();
                        }

                        Thread.sleep(500);
                    }
                } 
                catch (Exception e)
                {

                }
            }
        }
    }

    static class MyThread2 extends Thread
    {
        MyList list;

        public MyThread2(MyList list)
        {
            this.list = list;
        }

        @Override
        public void run()
        {
            synchronized (lock)
            {
                try
                {
                    if (list.getSize() != 5)
                    {
                        System.out.println("t2 begin wait");
                        lock.wait();
                        System.out.println("t2 end");
                    }

                } catch (Exception e)
                {

                }
            }

        }
    }
}

程序输出：
t2 begin wait
added
added
added
added
added
t1 notify
added
added
added
added
added
t2 end

t2 end最后才执行的原因是因为notify执行后，并不立即释放锁，其实这里也能看出来原因，如果notify后就释放，那后面的5次add方法就不再是线程安全的了。而wait方法则正好相反，执行后立即释放锁。

3、notify只随机唤醒一个wait的线程，需要唤醒所有wait线程时请使用notifyAll方法。

4、wait(time)是在time时间内等待被notify，如果超过这个时间的话，则自动唤醒。注意，自动唤醒时如果锁被其他线程占用，会继续wait直到锁释放。下面是例子：

package com.amuro.studythread.chapter3_communication;

public class WaitTime
{
    public static void main(String[] args)
    {
        final Object lock = new Object();
        Thread t1 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                synchronized (lock)
                {
                    try
                    {
                        System.out.println("t1 begin");
                        lock.wait(2000);
                        System.out.println("t1 end");
                    }
                    catch(Exception e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                synchronized (lock)
                {
                    try
                    {
                        System.out.println("t2 begin");
                        Thread.sleep(5000);
                        System.out.println("t2 end");
                    }
                    catch (Exception e) 
                    {

                    }
                }

            }
        });
        t2.start();
    }
}

5、使用wait/notify的注意点：
1) wait和notify的时序，如果先notify再wait会导致wait永远无法结束。
2）当使用notifyAll的时候要尤其小心，其他线程在wait()后的代码之间是否会发生冲突，比如同时从数组中remove一个元素导致越界。

6、实现生产消费者模式
1）单生产单消费

package com.amuro.studythread.chapter3_communication;

public class SinglePC
{
    public static void main(String[] args)
    {
        Object lock = new Object();
        P p = new P(lock);
        C c = new C(lock);

        Thread t1 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                while(true)
                {
                    p.set();
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                while(true)
                {
                    c.get();
                }
            }
        });
        t2.start();
    }

    static String value = "";

    static class P
    {
        Object lock;

        public P(Object lock)
        {
            this.lock = lock;
        }

        public void set()
        {
            synchronized (lock)
            {
                try
                {
                    if (!"".equals(value))
                    {
                        System.out.println("P wait");
                        lock.wait();
                    }

                    System.out.println("P set value");
                    value = System.currentTimeMillis() + "";
                    Thread.sleep(1000);
                    lock.notify();
                } 
                catch (Exception e)
                {

                }
            }
        }
    }

    static class C
    {
        Object lock;

        public C(Object lock)
        {
            this.lock = lock;
        }

        public void get()
        {
            synchronized (lock)
            {
                try
                {
                    if ("".equals(value))
                    {
                        System.out.println("C wait");
                        lock.wait();
                    }

                    System.out.println("C get value: " + value);
                    value = "";

                    Thread.sleep(1000);
                    lock.notify();
                } 
                catch (Exception e)
                {
                }
            }
        }
    }
}

2) 多生产多消费者时请不要使用notify，可能会导致假死。请使用notifyAll。同时在wait的进入条件判断时不要使用if，否则可能导致5（2）的问题，请使用while，具体见下面例子
多生产多消费实现stack：

package com.amuro.studythread.chapter3_communication;

import java.util.ArrayList;
import java.util.List;

public class SingleMultiCStack
{
    public static void main(String[] args)
    {
        MyStack stack = new MyStack();
        P p = new P(stack);
        C c = new C(stack);

        for(int i = 0; i < 10; i++)
        {
            MyThreadP tp = new MyThreadP(p);
            tp.setName("P" + i);
            tp.start();
        }

        for(int i = 0; i < 10; i++)
        {
            MyThreadC tc = new MyThreadC(c);
            tc.setName("C" + i);
            tc.start();
        }
    }

    static class MyStack
    {
        List<String> list = new ArrayList<>();

        synchronized void push()
        {
            try
            {
                while(list.size() == 1)
                {
                    System.out.println("push when size == 1, wait...");
                    this.wait();
                }

                Thread.sleep(2000);

                list.add("str " + Math.random());
                this.notifyAll();
                System.out.println("After push list size is " + list.size());
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        synchronized String pop()
        {
            String result = "";

            try
            {
                while(list.size() == 0)
                {
                    System.out.println("pop when size == 0, wait...");
                    this.wait();
                }

                Thread.sleep(2000);

                result = list.remove(0);
                this.notifyAll();
                System.out.println("After pop list size is " + list.size());
            }
            catch (Exception e) 
            {
                e.printStackTrace();
            }

            return result;
        }
    }

    static class P
    {
        MyStack stack;

        public P(MyStack stack)
        {
            this.stack = stack;
        }

        void push()
        {
            stack.push();
        }
    }

    static class C
    {
        MyStack stack;

        public C(MyStack stack)
        {
            this.stack = stack;
        }

        void pop()
        {
            System.out.println("C get a str: " + stack.pop());
        }
    }

    static class MyThreadP extends Thread
    {
        P p;

        public MyThreadP(P p)
        {
            this.p = p;
        }

        @Override
        public void run()
        {
            while(true)
            {
                p.push();
            }
        }
    }

    static class MyThreadC extends Thread
    {
        C c;

        public MyThreadC(C c)
        {
            this.c = c;
        }

        @Override
        public void run()
        {
            while(true)
            {
                c.pop();
            }
        }
    }
}

7、使用管道进行线程通信
1）字节流
PipedInputStream和PipedOutputStream
2）字符流
PipedReader和PipedWriter
具体例子请百度，这里不再赘述。

二、join

1、概念：很多情况下，例如在主线程中创建并启动了子线程，如果子线程中需要进行大量的耗时运算，那主线程往往会在子线程之前就结束。所以，当需要主线程等待子线程结束后再结束自身的情况下，就需要用到join。看下面例子：

package com.amuro.studythread.chapter3_communication;

public class JoinExample
{
    public static void main(String[] args) throws Exception
    {
        Thread t = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                try
                {
                    Thread.sleep(3000);
                } 
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }

                System.out.println("t1 end");
            }
        });
        t.start();
        t.join();
        System.out.println("main thread end");
    }

}

程序输出：
t1 end
main thread end

2、join方法被interrupt时，被阻塞的线程会抛出异常，而原线程则继续运行不受影响。

package com.amuro.studythread.chapter3_communication;

public class JoinException
{
    public static void main(String[] args) throws Exception
    {

        Thread t1 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                try
                {
                    System.out.println("t1 begin");
                    Thread.sleep(3000);
                    System.out.println("t1 end");
                } 
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                try
                {
                    t1.join();
                    System.out.println("t2 end");
                } 
                catch (Exception e)
                {
                    System.out.println("t2 join interrupted");
                }           

            }
        });
        t2.start();

        Thread.sleep(1000);
        t2.interrupt();

    }
}

程序输出：
t1 begin
t2 join interrupted
t1 end
可见t2在等待时被中断了，t1本身不受任何影响。

3、join(time) 设定等待的时间，和线程执行的时间相比，较短的优先。

4、sleep和join的区别，不释放锁和释放锁

package com.amuro.studythread.chapter3_communication;

public class JoinAndSleep
{
    public static void main(String[] args) throws Exception
    {
        ThreadB tb = new ThreadB();
        ThreadA ta = new ThreadA(tb);
        ThreadC tc = new ThreadC(tb);

        ta.start();
        Thread.sleep(1000);
        tc.start();
    }

    static class ThreadA extends Thread
    {
        ThreadB tb;

        public ThreadA(ThreadB tb)
        {
            super();
            this.tb = tb;
        }

        @Override
        public void run()
        {
            try
            {
                synchronized (tb)
                {
                    System.out.println("ta begin");
                    tb.start();
//                  Thread.sleep(6000);
                    tb.join(6000);
                    System.out.println("ta end");
                }
            }
            catch (Exception e) 
            {
                e.printStackTrace();
            }
        }
    }

    static class ThreadB extends Thread
    {

        @Override
        public void run()
        {
            try
            {
                System.out.println("tb begin");
                Thread.sleep(5000);
                System.out.println("tb end");
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        synchronized void test()
        {
            System.out.println("tb test");
        }
    }

    static class ThreadC extends Thread
    {
        ThreadB tb;

        public ThreadC(ThreadB tb)
        {
            this.tb = tb;
        }

        @Override
        public void run()
        {
            tb.test();
        }
    }
}

当运行sleep时，程序输出：
ta begin
tb begin
tb end
ta end
tb test
当运行join时，程序输出：
ta begin
tb begin
tb test
tb end
ta end
可见join被调用时，释放了锁，而sleep则不会。

三、ThreadLocal

1、ThreadLocal的作用是一个全局的盒子，盒子里可以存储每个线程的私有数据。

package com.amuro.studythread;

public class ThreadLocalExample
{
    static ThreadLocal<String> threadLocal = new ThreadLocal<>();

    public static void main(String[] args)
    {
        Thread t1 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                for(int i = 0; i < 10; i++)
                {
                    threadLocal.set("t1 : " + (i + 1));
                    System.out.println(threadLocal.get());
                }
            }
        });
        t1.start();

        Thread t2 = new Thread(new Runnable()
        {

            @Override
            public void run()
            {
                for(int i = 0; i < 10; i++)
                {
                    threadLocal.set("t2 : " + (i + 1));
                    System.out.println(threadLocal.get());
                }
            }
        });
        t2.start();
    }


}

程序输出：
1 : 1
t1 : 2
t1 : 3
t1 : 4
t1 : 5
t1 : 6
t1 : 7
t1 : 8
t1 : 9
t1 : 10
t2 : 1
t2 : 2
t2 : 3
t2 : 4
t2 : 5
t2 : 6
t2 : 7
t2 : 8
t2 : 9
t2 : 10
可以见t1和t2操作的都是同一个threadLocal，但ThreadLocal是线程安全的。

2、可以通过继承ThreadLocal来为其提供一个初始值：

static class MyThreadLocal extends ThreadLocal<String>
{
    @Override
    protected String initialValue()
    {
        return Thread.currentThread().getName();
    }

}

3、InheritableThreadLocal：子线程如果不调用set方法的话，会继承主线程中set的值。同时也可以通过复写childValue方法来提供子线程自己的value。

package com.amuro.studythread.chapter3_communication;

public class ThreadLocalExamplePro
{
    static class MyThreadLocal extends InheritableThreadLocal<String>
    {
        int count = 0;

        @Override
        protected String initialValue()
        {
            return "main";
        }

        @Override
        protected String childValue(String parentValue)
        {
            count++;
            return parentValue + " : " + count;
        }
    }

    static MyThreadLocal inThreadLocal = new MyThreadLocal();

    public static void main(String[] args) throws Exception
    {
        inThreadLocal.set("main");
        System.out.println(inThreadLocal.get());

        for(int i = 0; i < 10; i++)
        {
            new Thread(new Runnable()
            {

                @Override
                public void run()
                {
                    System.out.println(inThreadLocal.get());
                }

            }).start();
        }

    }
}

程序输出：
main
main : 1
main : 2
main : 3
main : 4
main : 5
main : 6
main : 7
main : 8
main : 9
main : 10

amurocrash
关注
专栏目录
Java并发编程进阶——多线程的安全与同步
行者无疆的博客
03-14 643
多线程的安全与同步 多线程的操作原则 多线程 AVO 原则 A：即 Atomic，原子性操作原则。对基本数据类型变量的读和写是保证原子性的，要么都成功，要么都失败，这些操作不可中断。 V：即 volatile，可见性原则。使用 volatile 关键字，保证了变量的可见性，到主存拿数据，不是到缓存里拿。 O：即 order， 就是有序性。代码的执行顺序，在代码编译前的和代码编译后的执行顺序不变。 单 CPU 时代的多线程 概念：单核 CPU 上，同一时刻只能有一条线程运行，单核 CPU 上运行的单线程程序和
java中ThreadLocal、InheritableThreadLocal详解
OceanSky的专栏
11-11 4528
一、ThreadLocal介绍 ​ 在多线程环境下访问同一个线程的时候会出现并发问题，特别是多个线程同时对一个变量进行写入操作时，为了保证线程的安全，通常会进行加锁来保证线程的安全，但是加锁又会造成效率的降低；ThreadLocal是jdk提供的除了加锁之外保证线程安全的方法，其实现原理是在Thread类中定义了两个ThreadLocalMap类型变量threadLocals、inheritableThreadLocals用来存储当前操作的ThreadLocal的引用及变量对象，这样就可以把当前线程的变
InheritableThreadLocal使用详解
秋夫人
09-18 5450
InheritableThreadLocal详解
ThreadLocal你搞懂了嘛？InternalThreadLocal ，FastThreadLocal如何做到提高性能
You’re a wanderer just like me
07-05 1123
一篇文章让你搞懂ThreadLocal，InternalThreadLocal，FastThreadLocal 这里写目录标题ThreadLocal一. 能干啥用？二. 使用非常广泛。举三个框架源码中的例子，大家品一品。1. Spring 的事务2. mybatis 的分页插件，PageHelper。3. Dubbo 的 RpcContext。三. 原理？四. 内存泄漏的问题？InternalThreadLocal一. 能干啥用的？二. 强在哪里？FastThreadLocal一. 能干啥用？二. 为什么快
浅谈ThreadLocal和InheritableThreadLocal，源码解析
qq_45604746的博客
06-16 413
浅谈ThreadLocal和InheritableThreadLocal
ThreadLocal，InheritableThreadLocal，TransmittableThreadLocal
上善若泪
03-20 1710
文章目录1 ThreadLocal1.1 基本理解1.2 应用1.2.1 使用场景1.2.2 在 Spring 中的使用->解决线程安全问题1.3 原理1.3.1 ThreadLocal的结构1.3.2 ThreadLocal 的方法1.3.3 ThreadLocal的内部类ThreadLocalMap1.4 总结 1 ThreadLocal 1.1 基本理解 ThreadLocal 是......
通过多线程编程在Java中发现的并发模式和特性——线程、锁、原子等.zip
最新发布
05-23
在Java编程中，多线程是处理并发执行的关键技术，它允许程序同时执行多个任务，提高了系统的效率和响应性。本资料主要探讨了Java中的并发模式和特性，...通过不断实践和学习，可以在Java并发编程领域达到更高的水平。
java并发编程——内存模型
02-24
并发——在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行——源自百度百科在并发编程中，我们需要...
并发编程——线程基础.pdf
06-06
总的来说，Java中的并发编程是一门综合技术，它涉及对线程生命周期的理解、线程间通信与协作、线程同步以及并发控制等多方面知识。通过学习并发编程，可以增强处理多任务的能力，提高程序的响应性和吞吐量。这对于...
ThreadLocal和InheritableThreadLocal的区别
Tracycater的专栏
05-15 1163
1、ThreadLocal 主要解决每个线程绑定自己的值，达到线程直接隔离。 1.1如果第一次访问没有设定初始值，返回为null 1.2线程直接的隔离性//继承ThreadLocal类 public class ThreadLocalExt extends ThreadLocal{ }//创建两个线程，分别设置自己的值 public class ThreadA extends Thread{
ThreadLocal和InheritableThreadLocal
weixin_44991304的博客
04-30 526
ThreadLocal 介绍： 变量值的共享可以使用public static变量的形式使用，所有的线程都可以使用同一个public static变量，那么有没有一个东西能够使每一个线程都拥有自己的变量呢？ThreadLocal就是解决这样的问题的。 ThreadLocal 类提供线程局部变量，它通常是私有类中希望将状态与线程关联的静态字段。 简而言之，就是 ThreadLocal 提供了线程间数据隔离的功能，从它的命名上也能知道这是属于一个线程的本地变量。也就是说，每个线程都会在 ThreadLoca
ThreadLocal、InheritableThreadLocal理解
weixin_43951597的博客
04-14 912
文章目录前言一、ThreadLocal是什么？1. 为什么使用了TreadLocal就保证了线程安全2. 为什么每次使用完TreadLocal就需要调用remove方法二、InheritableThreadLocal是什么？总结 前言 在我们日常开发过程中，我们常常会在当前线程中保存一些变量，如：当前线程的一些上下文信息、当前登录的用户、当前的request、response，为了避免多线程之间竞争，我们会使用ThreadLocal来保存相关的信息，为什么存在ThreadLocal中的变量就能保证线程安全
ThreadLocal和InherbritableThreadLocal使用
u010357298的博客
04-03 1372
初始值设置
ThreadLocal父子线程传递实现方案
蜗牛的专栏
09-30 2万+
前言 介绍InheritableThreadLocal之前，假设对 ThreadLocal 已经有了一定的理解，比如基本概念，原理，如果没有，可以参考：ThreadLocal源码分析解密.在讲解之前我们先列举有关ThreadLocal的几个关键点 每一个Thread线程都有属于自己的ThreadLocalMap,里面有一个弱引用的Entry(ThreadLocal,Object),
ThreadLocal及InheritableThreadLocal类实现原理
reachwang的博客
06-09 961
Thread使用方法 ThreadLocal提供了线程本地变量，也就是如果你创建了一个ThreadLocal变量，那么访问这个变量的每个线程其实都会有次变量的一个本地副本。所以多线程访问次变量实际操作的时自己线程本地内存里面的变量。直接上例子： static ThreadLocal<String> localVariable = new ThreadLocal<>(); ...
多线程中的ThreadLocal 详解
热门推荐
请叫我王老魔
05-19 3万+
要了解ThreadLocal，首先搞清楚ThreadLocal 是什么？是用来解决什么问题的？ThreadLocal 是线程的局部变量， 是每一个线程所单独持有的，其他线程不能对其进行访问， 通常是类中的 private static 字段，是对该字段初始值的一个拷贝，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联我们知道有时候一个对象的变量会被多个线程所访问，这时就会有线程安全
使用 ThreadLocal 或 InheritableThreadLocal 对线程内部对象做缓存，实现线程内对象的复用
m0_37822338的博客
08-21 587
在java.lang.Thread类中有两个属性 ThreadLocal.ThreadLocalMap threadLocals ThreadLocal.ThreadLocalMap inheritableThreadLocals 这里的ThreadLocalMap 类相当于一个Map，key 是 ThreadLocal 对象，value 就是存储的值。 threadLocals 里边的值...
ThreadLocal,InheritableThreadLocal，TransmittableThreadLocal应用场景及解析
u010590805的博客
11-03 422
ThreadLocal,TransmittableThreadLocal，使用解析。
java 多线程
李响
11-01 351
package step2; import java.util.Scanner; public class Task { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int num = sc.nextInt(); //请在此添加实现...
Java并发编程：内存模型与通信同步详解
Java并发编程——内存模型深入解析 Java并发编程的核心在于理解和管理多个线程之间的协作与同步。在并发编程的世界里，内存模型是关键的一环，它定义了多线程环境下对共享数据的操作规则。首先，让我们理解并发的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值