并发编程8

最新推荐文章于 2024-04-25 14:49:37 发布

Markland_l

最新推荐文章于 2024-04-25 14:49:37 发布

阅读量205

点赞数 1

分类专栏：并发编程文章标签：多线程

本文链接：https://blog.csdn.net/Markland_l/article/details/113729108

版权

并发编程专栏收录该内容

23 篇文章 0 订阅

订阅专栏

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就会继续执行，否则就阻塞

Markland_l

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
4
评论
并发编程8

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
复制链接

扫一扫

专栏目录