3/16day12_Synchronized_高并发线程安全类

今日内容

Synchronized关键字【重点】
高并发下JDK提供一堆的线程安全有关类【理解】

synchronized关键字【重点】

之前的AtomicInteger类只能保证"变量"的原子性操作，而对多行代码进行"原子性"操作，使用AtomicInteger 类就不能达到效果了。
线程安全问题都是由全局变量及静态变量引起的。而每个线程操作这个变量都需要很多步骤：获取变量的值、打印变量的值、更改变量的值，而一个线程在执行某一步骤时都可能被暂停，而另一个线程会执行，这同样会导致多个线程访问同一个变量，最终导致这个变量的值不准确。

synchronized关键字概述

synchronized关键字：表示“同步”的。它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体，一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。
synchronized被称为“重量级的锁”方式，也是“悲观锁”——效率比较低。
synchronized有几种使用方式：
a).同步代码块 b).同步方法 c).Lock锁

解放方法一：同步代码块

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式：

synchronized(同步锁对象){    
         需要同步操作的代码 
}

使用同步锁代码演示

public class Ticket implements Runnable{  
      private int ticket = 100;        
      Object lock = new Object();
 /*     
* 执行卖票操作     
*/    
@Override   
 public void run() {       
        //每个窗口卖票的操作         
        //窗口 永远开启        
       while(true){            
            synchronized (lock) {                      
                  if(ticket>0){//有票 可以卖
                   //出票操作 
                   //使用sleep模拟一下出票时间
                     try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    //获取当前线程对象的名字
                     String name = Thread.currentThread().getName();
                    System.out.println(name+"正在卖:"+ticket--);               
                   }
            }
        }
    }
 }

解决方法二：同步方法

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着。
格式

public synchronized void method(){
    可能会产生线程安全问题的代码 
}

同步方法代码演示

格式:
    public synchronized void 方法名(){
          需要同步的代码(需要保证原子性的代码)
    }

解决代码:
    /**
 * 卖票任务
 */
public class TicketTask implements Runnable{
    //定义变量,表示初始有100张票
    int count = 100;

    @Override
    public void run() {
        while (true){
           sellTicket();
        }
    }

    public synchronized void sellTicket(){
        if (count > 0) {
            //先判断,后卖票
            System.out.println("卖出第"+count+"张票!");
            //票数要减少
            count--;
        }
    }  
}

注意

同步锁和同步代码块
1.同步代码块和同步方法原理一样，同步代码块的同步锁需要自己指定，而同步方法的同步锁，默认使用当前对象this。
2.对于非static方法,同步锁就是this。
对于static方法,默认使用当前方法所在类的字节码对象(类名.class)。

解决方法三： Lock锁

Lock是一个接口，需要使用其实现类 ReentrantLock。
public ReentrantLock();
同步代码块/同步方法具有的功能Lock都有
Lock锁也称同步锁(悲观锁)，加锁与释放锁方法化了，如下：
public void lock() :加同步锁。
public void unlock() :释放同步锁。
Lock锁的代码演示

/**
 * 卖票任务
 */
public class TicketTask implements Runnable{
    //定义变量,表示初始有100张票
    int count = 100;
    //创建一个Lock锁
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            //加锁
            lock.lock();
                if (count > 0) {
                    //先判断,后卖票
                    System.out.println("卖出第"+count+"张票!");
                    //票数要减少
                    count--;
                }
            lock.unlock();
        }
    }
}

并发包

并发包概述：
在JDK的并发包里提供了几个非常有用的并发容器和并发工具类。供我们在多线程开发中进行使用。使用这些集合或者工具类时，能保证

CopyOnWriteArrayList

ArrayList的线程不安全最终结果可能会抛异常，或者最终集合大小是不正确的。
ArrayList和CopyOnWriteArrayLiST安全性的代码演示

public class MyThread extends Thread {

//    public static List<Integer> list = new ArrayList<>();//线程不安全的
    public static List<Integer> list = new CopyOnWriteArrayList<>();//保证线程安全

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            list.add(i);
        }
        System.out.println("添加完毕！");
    }
}
public class TestArrayList {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
        Thread.sleep(1000);
        System.out.println("最终集合的长度：" + MyThread.list.size());
    }
}

CopyOnWriteArraySet

HashSet仍然是线程不安全的：
CopyOnWriteArraySet和HashSet安全性代码演示

public class MyThread extends Thread {

//    public static List<Integer> list = new ArrayList<>();//线程不安全的
    public static List<Integer> list = new CopyOnWriteArrayList<>();//保证线程安全

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            list.add(i);
        }
        System.out.println("添加完毕！");
    }
}

ConcurrentHashMap

HashMap是线程不安全的。
Hashtable是线程安全的，但效率低
ConcurrentHashMap是线程安全的，但效率高
HashMap和ConcurrentHashMap 安全性代码演示

public class MyThread extends Thread {

    //public static Set<Integer> set = new HashSet<>();//线程不安全的
    public static Set<Integer> set = new CopyOnWriteArraySet<>();//线程安全的

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            set.add(i);
        }
        System.out.println("添加完毕！");
    }
}
public class TestSet {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.start();
        //主线程也添加10000个
        for (int i = 10000; i < 20000; i++) {
            MyThread.set.add(i);
        }

        Thread.sleep(1000 * 3);
        System.out.println("最终集合的长度：" + MyThread.set.size());
    }
}

ConcurrentHashMap比Hashtable效率高的原因
Hashtable对哈希表进行的是全表加锁，ConcurrentHashMap是对局部加锁（对桶或者说链表加锁）同时使用CAS机制。
ConcurrentHashMap 线程安全的map类， 16 把锁，16 个线程
线程1 锁第一个链表
线程2 锁第二个链表
Hashtable 线程安全的map类, 把整个集合加了一把锁， 16 线程，只有一个线程能用， 15 个得等
ConcurrentHashMap高效的原因：CAS + 局部(synchronized)锁定

CountDownLatch

CountDownLatch的作用
允许当前一个或多个线程等待其他线程完成操作。
CountDownLatch的API
- 构造方法：
  public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象,count指等待几个线程结束
- 成员方法：
  public void await() throws InterruptedException// 让当前线程等待
  public void countDown() // 计数器进行减1
CountDownLatch的案例代码

需求: 
    线程1要执行打印：A和C，线程2要执行打印：B
    我们需要这样的结果: 线程1 先打印A 线程2打印B 之后 线程1再打印C    
                    A  B  C

public class TestDemo {
    public static void main(String[] args) throws InterruptedException {
        //0.创建一个CountDownLatch
        CountDownLatch latch = new CountDownLatch(1);
        //1.创建两个线程
        Thread t1  = new MyThread1(latch);

        Thread t2 = new MyThread2(latch);

        t1.start();

        Thread.sleep(5000);
        t2.start();
    }
}
public class MyThread1 extends Thread {
    private CountDownLatch latch;
    public MyThread1(CountDownLatch latch){
        this.latch = latch;
    }
    @Override
    public void run() {
        System.out.println("A....");
        try {
            latch.await();//让当前线程等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("C....");
    }
}
public class MyThread2 extends Thread {
    private CountDownLatch latch;

    public MyThread2(CountDownLatch latch){
        this.latch = latch;
    }

    @Override
    public void run() {
        System.out.println("B....");
        //让latch的计数器减少1
        latch.countDown();
    }
}

CyclicBarrier

CyclicBarrier 的作用
让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。
CyclicBarrier 的API
- 构造方法：
  public CyclicBarrier(int parties, Runnable barrierAction)// 用于在线程到达屏障时，优先执行。第一个参数为需要的多少个线程到达。第二个参数为都到达之后需要执行的任务
  public int await()// 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞
CyclicBarrier 的代码演示

需求: 部门开会,假设部门有五个人,五个人都到达了才执行开会这个任务
    
public class TestPersonThread {
    public static void main(String[] args) throws InterruptedException {
        //0.创建一个CyclicBarrier
        CyclicBarrier barrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("人都齐了,开会吧");
            }
        });

        //1.创建五个线程
        PersonThread p1 = new PersonThread(barrier);
        PersonThread p2 = new PersonThread(barrier);
        PersonThread p3 = new PersonThread(barrier);
        PersonThread p4 = new PersonThread(barrier);
        PersonThread p5 = new PersonThread(barrier);
        //2.开启
        p1.start();
        p2.start();
        p3.start();
        p4.start();
        p5.start();
        //Thread.sleep(6000);
        //System.out.println("人都到了,开会吧...");
        //要求,人没到不开会,都到了立刻开会!!!
    }
}

public class PersonThread extends Thread {
    private CyclicBarrier barrier;
    public PersonThread(CyclicBarrier barrier){
        this.barrier = barrier;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(new Random().nextInt(6)*1000);
            System.out.println(Thread.currentThread().getName() + " 到了! ");
            //调用 barrier的await 表示线程到了
            try {
                barrier.await();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

补充:
    Math的静态方法
        public static double random(); //获取一个0(包括)到1(不包括)的正小数

Semaphore

Semaphore的作用
用于控制并发线程的数量
Semaphore的API
- 构造方法：
  public Semaphore(int permits) //permits 表示许可线程的数量
  public Semaphore(int permits, boolean fair) //fair 表示公平性，如果这个设为 true 的话，下次执行的线程会是等待最久的线程
- 成员方法：
  public void acquire() throws InterruptedException //表示获取许可
  public void release() //release() 表示释放许可
Semaphore的使用案例

public class MyThread extends Thread {
    private Semaphore semaphore;

    public MyThread(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run(){
        //从Semaphore获取线程的许可
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " 进入 时间=" + System.currentTimeMillis());
        try {
            Thread.sleep(100*new Random().nextInt(10));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 结束 时间=" + System.currentTimeMillis());
        //归还semaphore线程的许可
        semaphore.release();
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //0.创建Semaphore
        Semaphore semaphore = new Semaphore(3);

        //最多的并发线程数量为1
        for (int i = 0; i < 10; i++) {
            new MyThread(semaphore).start();
        }
    }
}

Exchanger

Exchanger作用
Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。
Exchanger的API
- 构造方法：
  public Exchanger()
- 成员方法：
  public V exchange(V x) // 参数为发给其他线程数据，返回值为其他线程返回的数据
Exchanger的代码演示

public class TestExchanger {
    public static void main(String[] args) throws InterruptedException {
        //0.创建一个线程间数据交互对象
        Exchanger<String> exchanger = new Exchanger<String>();

        //1.创建线程A
        ThreadA aThread = new ThreadA(exchanger);
        aThread.start();

        //休眠
        Thread.sleep(5000);

        ThreadB bThread = new ThreadB(exchanger);
        bThread.start();
    }
}

public class ThreadA extends Thread {
    private Exchanger<String> exchanger;

    public ThreadA(Exchanger<String> exchanger) {
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("线程A,要将礼物AAA,送给线程B...");
        //调用exchanger
        String result = null;
        try {
            result = exchanger.exchange("AAA");//阻塞
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程A,获取到线程B的礼物:"+result);
    }
}

public class ThreadB extends Thread {
    private Exchanger<String> exchanger;

    public ThreadB(Exchanger<String> exchanger) {
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        System.out.println("线程B,要将礼物BBB,送给线程A...");
        String result = null;
        try {
            result = exchanger.exchange("BBB");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程B,获取到线程A的礼物:"+result);
    }
}

今日小结

能够使用同步代码块解决线程安全问题【重点】
    synchronized(锁对象){
        需要同步的代码(需要保证原子性的代码)
    }
    锁对象,可以是任意对象
能够使用同步方法解决线程安全问题牌【重点】
    public synchronized void 方法名(){
        需要同步的代码(需要保证原子性的代码)
    }

能够使用Lock锁解决线程安全问题牌【重点】
    Lock lock = new ReentrantLock();
    lock.lock();
        需要同步的代码(需要保证原子性的代码)
    lock.unlock();
    
能够说明volatile关键字和synchronized关键字的区别
    volatile 能解决有序性和可见性
    原子类 能解决变量操作的原子性(有序性和可见性)
    synchronized 能解决多句代码的原子性(有序性和可见性)

能够描述CopyOnWriteArrayList类的作用
    代替多线程的情况,线程安全的ArrayList集合
能够描述CopyOnWriteArraySet类的作用
    代替多线程的情况,线程安全的HashSet集合
能够描述ConcurrentHashMap类的作用
    代替多线程的情况,线程安全的HashMap集合(比HashTable效率更好)
能够描述CountDownLatch类的作用
    可以允许一个线程等待另外一个线程执行完毕后再继续执行
能够描述CyclicBarrier类的作用
    让一组线程都到达某种条件后再执行某个任务
能够表述Semaphore类的作用
    控制多线程并发的最大数量 
能够描述Exchanger类的作用
    用于线程间的通信(数据交换)

最后编辑于：2020.03.18 16:09:18

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 217,277评论 6赞 503
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 92,689评论 3赞 393
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 163,624评论 0赞 353
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,356评论 1赞 293
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,402评论 6赞 392
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,292评论 1赞 301
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,135评论 3赞 418
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,992评论 0赞 275
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,429评论 1赞 314
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,636评论 3赞 334
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,785评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,492评论 5赞 345
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,092评论 3赞 328
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,723评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,858评论 1赞 269
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,891评论 2赞 370
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,713评论 2赞 354

3/16day12_Synchronized_高并发线程安全类

今日内容

synchronized关键字【重点】

synchronized关键字概述

解放方法一：同步代码块

解决方法二： 同步方法

注意

解决方法三： Lock锁

并发包

CopyOnWriteArrayList

CopyOnWriteArraySet

ConcurrentHashMap

CountDownLatch

CyclicBarrier

Semaphore

Exchanger

今日小结

推荐阅读更多精彩内容

解决方法二：同步方法