synchronized关键字的使用和优化
synchronized锁消除优化
-
package BingFaBianCheng.bingFaBianCheng8.shadow.test; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; @Slf4j(topic = "enjoy") public class Test7 { int i=0; public static void main(String[] args) throws InterruptedException { } public void a(){ i++; } public void b(){ Object o = new Object(); synchronized (o) { i++; } } }
-
a()方法和b()方法执行效率哪个高?
-
怎么证明哪个效率高?— jmh技术
- 可重复、可观测,执行10次,取平均结果
创建jmh项目
-
下面的命令会创建一个maven项目
-
mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jmh -DarchetypeArtifactId=jmh-java-benchmark-archetype -DgroupId=com.enjoy.jmh -DartifactId=zl -Dversion=1.0.0-SNAPSHOT -DarchetypeCatalog=local
-
会报错—searching for remote catalog,下载不下来一个文件,需要手动下载
-
并把它放到你的maven仓库中— archetype-catalog.xml
-
再在上面命令的基础上加一条-DarchetypeCatalog=local 表示用本地的,不用在线下载
利用创建的jmh项目测试上面两个方法
-
需要加一个pom引用----javax.annotation
-
@Fork(1)// 只fork一个线程 @BenchmarkMode(Mode.AverageTime)// 平均时间 @Warmup(iterations=3)// 预热 @Measurement(iterations=5)// 一共执行多少次 @OutputTimeUnit(TimeUnit.NANOSECONDS)// 时间单位 public class MyBenchmark { static int i =1; @Benchmark public void a(){ i++; } // 这两个方法时间差不多 // 因为jit对代码做了优化,锁消除 // 因为这是一个局部对象,这个对象没有逃出这个方法,加锁没有任何意义 @Benchmark public void b(){ Object o = new Object(); synchronized (o) { i++; } } }
-
利用idea中maven下的package方法直接打包
-
在target下生成了两个jar包,一个项目自己的,一个benchmarks.jar
-
然后执行java -jar benchmarks.jar
-
运行a方法执行时间和运行b方法执行时间是差不多的,都是2.6纳秒左右
-
jit(即时编译器)
- i++和带有synchronized的i++方法(锁是一个局部对象),用jmh测试出来效率基本一样
- 分析
- i++这个方法一直在锁里面,
- 锁消除:以局部变量作为锁对象,jit会认为这个synchronized没有用,会去掉
测试锁消除
-
@Fork(1)// 只fork一个线程 @BenchmarkMode(Mode.AverageTime)// 平均时间 @Warmup(iterations=3)// 预热 @Measurement(iterations=5)// 一共执行多少次 @OutputTimeUnit(TimeUnit.NANOSECONDS)// 时间单位 public class MyBenchmark { static int i =1; @Benchmark public void a(){ i++; } static Object o = new Object(); @Benchmark public void b(){ synchronized (o) { i++; } } }
-
此时a方法执行时间还是2.6纳秒,b方法执行时间是31纳秒,差别在10倍以上
-
锁粗化很难证明
线程切换问题
-
@Slf4j(topic = "enjoy") public class BasicLock { public synchronized void x(){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } log.debug("x"); } public synchronized void y(){ log.debug("y"); } }
-
/** * 1、等1s 打印x 打印y * 2、先打印y 等1s x */ @Slf4j(topic = "enjoy") public class TestBasic { public static void main(String[] args) { BasicLock basicLock = new BasicLock(); new Thread(()->{ log.debug("start"); basicLock.x(); },"t1").start(); new Thread(()->{ log.debug("start"); basicLock.y(); },"t2").start(); } }
-
虽然x方法睡眠了一秒钟,但是x方法和y方法到底谁先执行是随机的
静态方法和普通方法的两把锁测试
-
@Slf4j(topic = "enjoy") public class BasicLock1 { public synchronized static void x(){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } log.debug("x"); } public synchronized void y(){ log.debug("y"); } public void z(){ log.debug("z"); } }
-
/** * 永远y之前 */ @Slf4j(topic = "enjoy") public class TestBasic3 { public static void main(String[] args) { BasicLock basicLock = new BasicLock(); BasicLock basicLock1 = new BasicLock(); new Thread(()->{ log.debug("start"); basicLock.x(); },"t1").start(); new Thread(()->{ log.debug("start"); basicLock1.y(); },"t2").start(); } }
-
这是两把不互斥的锁,所以不会互相影响,而x又会睡眠一秒钟,所以百分之百是y方法先执行
同一个对象,但是方法一个是静态方法,一个是普通方法
-
import lombok.extern.slf4j.Slf4j; @Slf4j(topic = "enjoy") public class TestBasic4 { public static void main(String[] args) { BasicLock1 basicLock1 = new BasicLock1(); new Thread(()->{ log.debug("start"); basicLock1.x(); },"t1").start(); new Thread(()->{ log.debug("start"); basicLock1.y(); },"t2").start(); } }
-
x锁的是BsicLock1.class类对象
-
y锁的是this,实例对象
-
对象不对,synchronized锁不同的对象,也是彼此互不影响
synchronized基本使用
demo1
锁住实例
-
package com.shadow.demo1; import lombok.extern.slf4j.Slf4j; /** * synchronized关键字 * synchronized关键字锁定的是对象不是代码块,demo中锁的是object对象的实例 * 锁定的对象有两种:1.类的实例 2.类对象(类锁) * 加synchronized关键字之后不一定能实现线程安全,具体还要看锁定的对象是否唯一。 */ @Slf4j(topic = "enjoy") public class Demo1 { private int count = 10; private Object object = new Object(); public void test(){ synchronized (object){ count--; log.debug(Thread.currentThread().getName() + " count = " + count); } } }
-
实际锁住的是object里面的对象头
锁住实例2
-
package com.shadow.demo1; import lombok.extern.slf4j.Slf4j; @Slf4j(topic = "enjoy") public class Demo2 { private int count = 10; public void test(){ //synchronized(this)锁定的是当前类的实例,这里锁定的是Demo2类的实例 synchronized (this){ count--; log.debug(Thread.currentThread().getName() + " count = " + count); } } }
-
此时锁住的是demo2实例的对象头
锁住方法
-
package com.shadow.demo1; import lombok.extern.slf4j.Slf4j; @Slf4j(topic = "enjoy") public class Demo3 { private int count = 10; //直接加在方法声明上,相当于是synchronized(this) public synchronized void test(){ count--; log.debug(Thread.currentThread().getName() + " count = " + count); } }
-
相当于锁住this
锁住静态方法
-
package com.shadow.demo1; import lombok.extern.slf4j.Slf4j; @Slf4j(topic = "enjoy") public class Demo4 { private static int count = 10; //synchronize关键字修饰静态方法锁定的是类的对象 public synchronized static void test(){ count--; log.debug(Thread.currentThread().getName() + " count = " + count); } public static void test2(){ synchronized (Demo4.class){//这里不能替换成this count--; } } }
-
静态方法不能锁住this,一定要锁住静态对象Demo4.class
demo2
死循环不释放锁,导致其他线程无法执行
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo2; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * 锁对象的改变 * 锁定某对象o,如果o的属性发生改变,不影响锁的使用 * 但是如果o变成另外一个对象,则锁定的对象发生改变 * 应该避免将锁定对象的引用变成另外一个对象 */ @Slf4j(topic = "enjoy") public class Demo1 { Object o = new Object(); public void test(){ synchronized (o) { //t1 在这里无线执行 while (true) { try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } log.debug(Thread.currentThread().getName()); } } } public static void main(String[] args) { Demo1 demo = new Demo1(); new Thread(demo :: test, "t1").start(); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } Thread t2 = new Thread(demo :: test, "t2"); //demo.o = new Object(); //t2能否执行? t2.start(); } }
-
t2不能执行
-
但是如果更改了锁对象,此时t2也能获取到锁,因为t1一直在死循环,而相当于换了一把新锁,就锁已经失效了,所以此时t2可以获取到锁
-
因为不要轻易替换锁对象
字符串作为锁定的对象
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo2; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * 不要以字符串常量作为锁定的对象 * */ @Slf4j(topic = "enjoy") public class Demo2 { String s1 = "hello"; String s2 = "hello"; public void test1(){ synchronized (s1) { log.debug("t1 start..."); try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); } log.debug("t1 end..."); } } public void test2(){ synchronized (s2) { log.debug("t2 start..."); } } public static void main(String[] args) { Demo2 demo = new Demo2(); //启动t1 new Thread(demo :: test1,"t1").start(); //启动t2 new Thread(demo :: test2,"t2").start(); } }
-
虽然s1和s2是两个不同的引用,实际上s1和s2是常量池里同一个对象,所以是同一把锁
-
所以尽量不要用字符串作为锁
锁的粒度
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo2; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * 同步代码快中的语句越少越好 * 比较test1和test2 * 业务逻辑中只有count++这句需要sync,这时不应该给整个方法上锁 * 采用细粒度的锁,可以使线程争用时间变短,从而提高效率 */ @Slf4j(topic = "enjoy") public class Demo3 { int count = 0; public synchronized void test1(){ try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } count ++; try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } } /** * 局部加锁 */ public void test2(){ try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (this) { count ++; } try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } } }
-
没有必要对整个代码加锁,只应该对读写区域进行加锁
-
synchronized只对有io操作的部分加持才有,比如锁住Thread.sleep方法没有任何影响,控制锁的粒度,提高效率
demo3
多线程非同步状态造成计算错误— count–
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo3; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * 第一个线程减了个1变成9了,还没打印,第二个线程又减了个1,第三个线程又减了个1, * 这时候虽然第一个线程只减了一个1但是却打印出来一个7(这里情况是不一定的) * 可以给方法加上synchronized */ @Slf4j(topic = "enjoy") public class Demo1 implements Runnable{ private int count = 10; @SneakyThrows @Override public synchronized void run() { //TimeUnit.SECONDS.sleep(1); /** * get * -- * set */ count--; log.debug(Thread.currentThread().getName() + " count = " + count); } public static void main(String[] args) { Demo1 demo = new Demo1(); for (int i = 0; i < 5; i++) { new Thread(demo,"t" + i).start(); } } }
-
因为count–不是一个原子性操作,造成计算错误
锁不同的对象,同步锁没有起作用
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo3; import lombok.extern.slf4j.Slf4j; @Slf4j(topic = "enjoy") public class Demo2 implements Runnable{ private int count = 10; @Override public synchronized void run() { count--; log.debug(Thread.currentThread().getName() + " count = " + count); } public static void main(String[] args) { for (int i = 0; i < 5; i++) { //相比较Demo1,这里是new了五个对象,每个线程对应都拿到各自的锁标记,可以同时执行。 Demo2 demo = new Demo2(); new Thread(demo,"t" + i).start(); } } }
-
每一个线程都有去获取锁,但是获取的是不同的锁,所以没有起到线程隔离的作用
demo4
同步方法可不可以调用非同步方法
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo4; import lombok.extern.slf4j.Slf4j; //同步方法和非同步方法是否可以同时调用? 可以 @Slf4j(topic = "enjoy") public class Demo{ public synchronized void test1(){ log.debug(Thread.currentThread().getName() + " test1 start..."); try { //睡眠5s 由于还要t2要执行 cpu回去执行t2 Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } log.debug(Thread.currentThread().getName() + " test1 end..."); } public void test2(){ try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " test2"); } public static void main(String[] args) { Demo demo = new Demo(); //正在执行一个同步方法 没有释放锁 new Thread(demo :: test1,"t1").start(); //不影响其他线程执行非同步方法(就算他是一个同步方法,如果锁的不是同一个对象也不影响) new Thread(demo :: test2,"t2").start(); } }
-
执行同一个类中的同步方法不会影响同一类中的非同步方法,即一个线程执行同步方法了,又来一个线程执行同一类中的非同步方法,后一个线程不会因为前一个线程而阻塞,是会同时并发执行的
-
实质上还是因为不是同一把锁,非同步方法都没有锁,所以就更不是同一把锁了
demo5
脏读问题
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo5; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * 脏读问题 * 实际业务当中应该看是否允许脏读, * 不允许的情况下对读方法也要加锁 */ @Slf4j(topic = "enjoy") public class Demo { //卡的持有人 String name; //卡上的余额 double balance; /** * * @param name * @param balance */ public synchronized void set(String name,double balance){ this.name = name; try { // 模拟存钱耗时 // 操作数据库,服务调用等等... Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } this.balance = balance; } public synchronized double getBalance(String name){ return this.balance; } public static void main(String[] args) { Demo demo = new Demo(); //2s new Thread(()->demo.set("zl",100.0)).start(); try { // 睡眠1秒钟 TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } //1s之后 结果 0 // 此时还有存完钱 log.debug(demo.getBalance("zl")+"");// try { // 睡眠2秒钟 TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } //3s之后就算100 // 此时已经存完钱了 log.debug(demo.getBalance("zl")+""); } }
-
一个人正在存,一个人正在取,会产生脏读问题,读取到了中间结果
-
项目是否允许脏读问题? — 架构师决定
-
如果不允许脏读,读取余额的时候也加锁,此时不是立马返回结果的,会转菊花,所以读是否加锁,需要看实际项目中是否允许脏读
demo6
锁的重入
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo6; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; //一个同步方法调用另外一个同步方法,能否得到锁? //重入 synchronized默认支持重入 @Slf4j(topic = "enjoy") public class Demo { synchronized void test1(){ log.debug("test1 start........."); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } test2(); } /** * 为什么test2还需要加sync * * 他本身就包含在test1 而test1已经加了sync */ synchronized void test2(){ try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } log.debug("test2 start......."); } public static void main(String[] args) { Demo demo= new Demo(); demo.test1(); } }
-
为什么test2还要加synchronized? t2本身就包含在t1中,t1又加了synchronized
-
为了防止别的方法直接调用t2,而synchronized本身是支持锁重入的
demo7
锁重入的另一种情况—继承
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo7; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; //这里是重入锁的另外一种情况,继承 @Slf4j(topic = "enjoy") public class Demo { synchronized void test(){ log.debug("demo test start........"); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } log.debug("demo test end........"); } public static void main(String[] args) { new Demo2().test(); } } @Slf4j(topic = "enjoy") class Demo2 extends Demo { @Override synchronized void test(){ log.debug("demo2 test start........"); super.test(); log.debug("demo2 test end........"); } }
-
子类重写的父类同步方法,又再次调用父类的同步方法,是可以调用的,说明父类和子类用的是同一个锁对象,也算是一种重入
demo8
synchronized里面发生异常
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo8; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.TimeUnit; /** * synchronized 和异常的关系 * T2线程能否执行? */ @Slf4j(topic = "enjoy") public class Demo { Object o = new Object(); int count = 0; void test(){ synchronized(o) { //t1进入并且启动 log.debug(Thread.currentThread().getName() + " start......"); //t1 会死循环 t1 讲道理不会释放锁 while (true) { count++; log.debug(Thread.currentThread().getName() + " count = " + count); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } //加5次之后 发生异常 /** * 如果程序发生异常如果没有try 则会释放锁 * 反之不会释放锁 */ if (count == 5) { int i = 1 / 0; } } } } public static void main(String[] args) { Demo demo11 = new Demo(); // Runnable r = () -> demo11.test(); // new Thread(r, "t1").start(); new Thread(()->{ demo11.test(); },"t1").start(); try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(()->{ demo11.test(); }, "t2").start(); } }
-
线程t1中除法运算会发生异常,如果没有try-catch,会释放锁,此时t2获取到锁
-
线程t1中除法运算发生异常,如果try-catch了,此时会一直死循环,不释放锁
demo9
并发编程中最主要的问题
-
package com.shadow.demo9; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; /** * volatile 关键字,使一个变量在多个线程间可见 * mian,t1线程都用到一个变量,java默认是T1线程中保留一份副本,这样如果main线程修改了该变量, * t1线程未必知道 * * 使用volatile关键字,会让所有线程都会读到变量的修改值 * * 在下面的代码中,running是存在于堆内存的t对象中 * 当线程t1开始运行的时候,会把running值从内存中读到t1线程的工作区,在运行过程中直接使用这个副本, * 并不会每次都去读取堆内存,这样,当主线程修改running的值之后,t1线程感知不到,所以不会停止运行 * * * 但是这可能是个错误 * 关于这个例子 在后面会专门花时间再讲 */ @Slf4j(topic = "enjoy") public class Demo { boolean running = true; List<String> list = new ArrayList<>(); /** * t1线程 */ public void test(){ log.debug("test start..."); boolean flag =running; while (running){ } log.debug("test end..."); } public static void main(String[] args) { Demo demo = new Demo(); new Thread(demo :: test,"t1").start(); try { // 主线程睡眠100毫秒,此时t1一定会被调用运行 // t1一直在死循环空转 Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } // 修改了死循环的中断条件 // 但是仍然无法停止空转 demo.running = false; } }
-
是不是中间变量的可见性问题?
- main线程私有栈、t1线程私有栈、共享变量字段running(存在堆里面)
-
怎么终止死循环?
-
1.在while死循环加一句打印(sout)(同步方法),死循环就会停止,
-
2.定义一个全局变量list,然后在while死循环里面,list.add(xx),死循环也会停止
-
3.在共享变量前面加volatile,死循环也会停止
- volatile实际是禁止了指令重排序,跟可见性没有关系
-
-
为什么去掉共享变量的volatile就不能终止死循环了?
-
jvm自身的激进优化
-
test方法运行在t1的线程中,在死循环中每次跨栈去拿running时,jvm发现while中什么都没有做,发现没有任何意义,会对这段代码进行优化,会新增一个临时变量,把共享变量赋值给临时变量,然后先判断这个临时变量,而不是跨栈去查共享变量(effective java这本书242页)(R大)
-
boolean flag =running; if(flag){ while (running){ } }
-
java基本没有可见性问题,happens before原则已经规避了可见性问题
-
这个问题的优化是在机器码这个级别解决(指令级别优化),不是在class文件级别
-
demo10
volatile不能解决原子性,只能保证可见性
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo10; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; /** * 比如说第一个线程加到100了,还没往上加,另外一个线程来了,把100拿过来执行方法, * 然后第一个线程继续加到101,第二个线程也加到101,他两往回写都是101,线程不会管你加到哪儿了, * 虽然说加了2但是实际上只加了1. * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题, * 也就是说volatile不能替代synchronized或者说volatile保证不了原子性 */ @Slf4j(topic = "enjoy") public class Demo { volatile int count = 0; public void test(){ for (int i = 0; i < 10000; i++) { count ++; } } public static void main(String[] args) { Demo demo = new Demo(); List<Thread> threads = new ArrayList(); //new 10個线程 for (int i = 0; i < 10; i++) { threads.add(new Thread(demo::test, "t-" + i)); } //遍历这个10个线程 依次启动 threads.forEach((o)->o.start()); //等待10个线程执行完 threads.forEach((o)->{ try { o.join(); } catch (Exception e) { e.printStackTrace(); } }); log.debug(demo.count+""); } }
-
count++不是原子性操作,有3步操作,get 、++、set
-
volatile替代synchronized,synchronized可以同时保证可见性和原子性
demo11
synchronized既保证了原子性又保证了可见性
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo11; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; @Slf4j(topic = "enjoy") public class Demo { int count = 0; //相比较上一个例子,synchronized既保证了原子性又保证了可见性 public synchronized void test(){ for (int i = 0; i < 10000; i++) { count ++; } } public static void main(String[] args) { Demo demo = new Demo(); List<Thread> threads = new ArrayList<Thread>(); for (int i = 0; i < 10; i++) { threads.add(new Thread(demo::test, "thread-" + i)); } threads.forEach((o)->o.start()); threads.forEach((o)->{ try { o.join(); } catch (Exception e) { e.printStackTrace(); } }); log.debug(demo.count+""); } }
demo12
AtomicInteger
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo12; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; /** * atomicXXX * 一道面试题:多个atomic类连续调用能否构成原子性? */ @Slf4j(topic = "enjoy") public class Demo { AtomicInteger count = new AtomicInteger(0); public void test(){ for (int i = 0; i < 10000; i++) { if(count.get() < 1000){ //count++ count.incrementAndGet(); } } } public static void main(String[] args) { Demo demo = new Demo(); List<Thread> threads = new ArrayList(); for (int i = 0; i < 10; i++) { threads.add(new Thread(demo::test, "thread-" + i)); } threads.forEach((o)->o.start()); threads.forEach((o)->{ try { o.join(); } catch (Exception e) { e.printStackTrace(); } }); log.debug(demo.count+""); } }
-
单个atomic操作是原子性的
- count.incrementAndGet(),是原子性的count++
-
多个atomic操作不是原子性的
-
if(count.get() < 1000){ //count++ count.incrementAndGet(); }
-
此时计算结果还是可能有问题,因为还是有线程切换
-
-
这种多原子操作的,只能通过加锁来解决
demo13
线程安全的list
-
package com.shadow.demo13; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; import java.util.concurrent.TimeUnit; /** * 一道面试题:实现一个容器,提供两个方法,add,size * 写两个线程,线程1添加10个元素到容器中,线程2实现监控元素的个数, * 当个数到5个时,线程2给出提示并结束线程2 * * 这里list在两个线程之间不保证可见性,所以线程2始终结束不了 */ @Slf4j(topic = "enjoy") public class Container1 { List lists = new ArrayList(); public void add(Object o){ lists.add(o); } public int size(){ return lists.size(); } public static void main(String[] args) { Container1 c = new Container1(); new Thread(()->{ for (int i = 0; i < 10; i++) { c.add(new Object()); log.debug("add " + i); try { TimeUnit.SECONDS.sleep(1); } catch (Exception e) { e.printStackTrace(); } } }," t1").start(); new Thread(()->{ while (true) { if (c.size() == 5) { break; } } log.debug("t2线程结束"); }, "t2").start(); } }
-
此时t2压根就不会结束,
改进list–加volatile
-
package com.shadow.demo13; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; import java.util.concurrent.TimeUnit; /** * 一道面试题:实现一个容器,提供两个方法,add,size * 写两个线程,线程1添加10个元素到容器中,线程2实现监控元素的个数, * 当个数到5个时,线程2给出提示并结束 * * 有两个问题,第一由于没有加同步,可能size等于5的时候,有另外一个线程加了一下才break,不是很精确 * 第二个问题就是浪费cpu,T2线程用的是死循环 */ @Slf4j(topic = "enjoy") public class Container2 { volatile List lists = new ArrayList(); public void add(Object o){ lists.add(o); } public int size(){ return lists.size(); } public static void main(String[] args) { Container2 c = new Container2(); new Thread(()->{ for (int i = 0; i < 10; i++) { c.add(new Object()); log.debug("add " + i); try { TimeUnit.SECONDS.sleep(1); } catch (Exception e) { e.printStackTrace(); } } }," t1").start(); /** * 浪费性能 * 当条件不满足的我应该放弃CPU 阻塞 * 当条件满足的时候才执行 wait notify */ new Thread(()->{ while (true) { if (c.size() == 5) { break; } } log.debug("t2线程结束"); }, "t2").start(); } }
-
理论还是存在问题,如果不睡眠,就会更容易出现,假设当list的size加到5个了,t2执行c.size==5的判断时,时间片又给t1了,并且又加了1个,此时再切换为线程t2时,已经不满足了,完美错过,还会是死循环
-
这个问题在多核电脑上很难复现,单核电脑上则很容易复现
-
最大的问题还是浪费性能,一直死循环
持续优化,当条件不满足时放弃cpu,而不是空转浪费cpu
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo13; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; import java.util.concurrent.TimeUnit; /** * 一道面试题:实现一个容器,提供两个方法,add,size * 写两个线程,线程1添加10个元素到容器中,线程2实现监控元素的个数,当个数到5个时, * 线程2给出提示并结束 * * 这里虽然T2能够及时收到消息唤醒,但是wait会释放锁,notify不会释放锁,所以T1线程结束后 * T2线程才执行完成 */ @Slf4j(topic = "enjoy") public class Container3 { volatile List lists = new ArrayList(); public void add(Object o){ lists.add(o); } public int size(){ return lists.size(); } public static void main(String[] args) { Container3 c = new Container3(); Object lock = new Object(); new Thread(()->{ synchronized (lock) { log.debug("t2启动"); if (c.size() != 5) { try { lock.wait(); } catch (Exception e) { e.printStackTrace(); } } log.debug("t2结束"); } }," t2").start(); new Thread(()->{ log.debug("t1启动"); synchronized (lock) { for (int i = 0; i < 10; i++) { c.add(new Object()); log.debug("add " + i); if (c.size() == 5) { lock.notify(); } try { TimeUnit.SECONDS.sleep(1); } catch (Exception e) { e.printStackTrace(); } } } }, "t1").start(); } }
-
wait会释放锁,notify不会释放锁
-
t2被唤醒后,会进入entryList去抢锁,但是此时t1都没有释放锁,所以t2拿不到锁,一直要到t1释放锁后才能执行
t1再次wait释放锁
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo13; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; import java.util.concurrent.TimeUnit; /** * 一道面试题:实现一个容器,提供两个方法,add,size * 写两个线程,线程1添加10个元素到容器中,线程2实现监控元素的个数, * 当个数到5个时,线程2给出提示并结束 * * 相比较上一个例子,这里T1里面用wait释放锁,T2能够及时结束 */ @Slf4j(topic = "enjoy") public class Container4 { volatile List lists = new ArrayList(); public void add(Object o){ lists.add(o); } public int size(){ return lists.size(); } public static void main(String[] args) { Container4 c = new Container4(); Object lock = new Object(); new Thread(()->{ synchronized (lock) { log.debug("t2启动"); while (c.size() < 5) { try { lock.wait(); } catch (Exception e) { e.printStackTrace(); } } log.debug("t2结束"); // 再次唤醒t1 lock.notify(); } }," t2").start(); new Thread(()->{ log.debug("t1启动"); synchronized (lock) { for (int i = 0; i < 10; i++) { c.add(new Object()); log.debug("add " + i); if (c.size() == 5) { lock.notify(); try { lock.wait();//要释放锁,T2才能得到锁得以执行 } catch (Exception e) { e.printStackTrace(); } } try { TimeUnit.SECONDS.sleep(1); } catch (Exception e) { e.printStackTrace(); } } } }, "t1").start(); } }
两个线程来回wait-notify,很别扭,有没有更优的方法
-
package BingFaBianCheng.bingFaBianCheng8.shadow.demo13; import lombok.extern.slf4j.Slf4j; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.TimeUnit; /** * 一道面试题:实现一个容器,提供两个方法,add,size * 写两个线程,线程1添加10个元素到容器中,线程2实现监控元素的个数, * 当个数到5个时,线程2给出提示并结束 * * CountDownLatch * 使用await和countdown方法替代wait和notify * CountDownLatch不涉及锁定,当count的值为零时当前线程继续运行 * 相当于是发令枪,运动员线程调用await等待,计数到0开始运行 * 当不涉及同步,只是涉及线程通信的时候,用synchronized加wait,notify就显得太重了 */ @Slf4j(topic = "enjoy") public class Container5 { volatile List lists = new ArrayList(); public void add(Object o){ lists.add(o); } public int size(){ return lists.size(); } public static void main(String[] args) { Container5 c = new Container5(); CountDownLatch latch = new CountDownLatch(1); String s = new String("XXXXX"); new Thread(()->{ log.debug("t2启动"); try { //阻塞 latch.await();//准备 } catch (Exception e) { e.printStackTrace(); } log.debug("t2结束"); }," t2").start(); new Thread(()->{ log.debug("t1启动"); for (int i = 0; i < 10; i++) { c.add(new Object()); log.debug("add " + i); if (c.size() == 5) { // 因为countDownLatch等于1 // 释放一次后就等于0了 latch.countDown(); } try { TimeUnit.SECONDS.sleep(1); } catch (Exception e) { e.printStackTrace(); } } }, "t1").start(); } }
-
只有当CountDownLatch等于0的时候,会自动把所有因为countDownLatch阻塞的线程全部唤醒,所以此时t2就会继续执行,否则就阻塞