多线程之JUC

多线程之JUC 1、什么是JUC？

JUC是java.util.concurrent的简写

在jdk官方手册中可以看到JUC相关的jar包有三个。

JUC的意思就是java并发编程工具包

并发编程的本质就是充分利用CPU资源

进程、线程进程

进程是指在系统中正在运行的一个应用程序，程序一旦运行就是进程。

进程是系统进行资源分配的独立实体，且每个进程拥有独立的地址空间。

一个进程可以拥有多个线程，每个线程使用其所属进程的栈空间。

线程

线程是进程的一个实体，是进程的一条执行路径。

线程是CPU独立运行和独立调度的基本单位。

进程：一个程序，QQ.exe Music.exe 程序的集合；
一个进程往往可以包含多个线程，至少包含一个！

java默认有几个线程？

2个线程 main线程、GC线程

线程：开了一个进程Typora，写字，自动保存（线程负责的）
对于Java创建线程方式：Thread、Runnable、Callable

Java真的可以开启线程吗？

开不了，用native本地方法调用底层的C++开启的！java无法操作硬件！

这里我们可以看下一原码，在源码中发现java调用的是 private native void start0();

native修饰，所以可以知道java调用的是本地方法接口，就是底层的c写的开启方法。

    public synchronized void start() {
        
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                
            }
        }
    }

    private native void start0();

并发编程：并发、并行
并发(多线程操作同一个资源)

CPU一核，模拟出来多条线程
并行(多个人一起行走)

CPU多核，多个线程可以同时执行；线程池

线程有几种状态？

六种

可以通过Thread.State来看一下其中的状态。中间的注解是解释文档看不懂的可以去百度翻译

    public enum State {
        
        //创建
        NEW,

        
        //运行
        RUNNABLE,

        
        //阻塞
        BLOCKED,

        
        //等待，一直等待
        WAITING,

        
        //超时等待，
        TIMED_WAITING,

        
        //终止
        TERMINATED;
    }

wait/sleep的区别

来自不同的类

wait来自object，sleep来自Thread

企业中一般不会使用这两个方法来使线程等待

import java.util.concurrent.TimeUnit;
//没有截全图，只是想说明这个类来自java.util.concurrent.TimeUnit;    JUC
TimeUnit.DAYS.sleep(1);//等待一天
        TimeUnit.HOURS.sleep(1);//等待一小时
        TimeUnit.SECONDS.sleep(1);//等待一秒
        TimeUnit.MINUTES.sleep(1);//等待一分钟
        TimeUnit.MICROSECONDS.sleep(1);//等待一微秒
        TimeUnit.MILLISECONDS.sleep(1);//等待一毫秒
        TimeUnit.NANOSECONDS.sleep(1);//等待一纳秒

是否释放锁

wait会释放锁，sleep睡觉了，抱着锁，不会释放，而且不会释放一切资源一直占有。

使用的范围是不同的

wait：必须在同步代码块中
sleep：可以在任何地方睡

是否需要捕获异常

wait：不需要捕获异常，会有一个中断异常，可以抛出

try {
            new ThreadDemo().wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

sleep：需要捕获异常

Lock锁*

传统Synchronized

//传统的线程开发
package sang.threads;
//线程就是一个单独的资源类，没有任何附属的操作！
//里面只包含1、属性，2、方法
public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(new threadTest());
        thread.start();
    }
}
class threadTest implements Runnable{

    @Override
    public void run() {
        
    }
}

举例瞅瞅：

package sang.threads;


public class ThreadDemo {
    public static void main(String[] args) {
      threadTest test = new threadTest();
      new Thread(() -> {
          for (int i = 0; i < 52; i++) {
              test.sale();
          }
      },"A").start();
      new Thread(() -> {
          for (int i = 0; i < 52; i++) {
              test.sale();
          }
      },"B").start();
    new Thread(() -> {
        for (int i = 0; i < 52; i++) {
            test.sale();
        }
    },"C").start();
    }
}

//资源类 OOP思想
class threadTest {
    //属性、方法
    private int number = 50;
    //synchronized本质上就是排队
    public synchronized void sale(){
        if (number>0) {
            System.out.println(Thread.currentThread().getName() + "卖出了第：" + (number--) + "张票,还剩：" + number + "张票");
        }
    }
}

OOP:面向对象程序设计(Object Oriented Programming)

Synchronized的作用

在JDK1.5之前都是使用synchronized关键字保证同步的

它可以把任意一个非NULL的对象当作锁。

作用于方法时，锁住的是对象的实例(this)；
当作用于静态方法时，锁住的是Class实例，又因为Class的相关数据存储在永久带PermGen（jdk1.8则是metaspace），永久带是全局共享的，因此静态方法锁相当于类的一个全局锁，会锁所有调用该方法的线程；
synchronized作用于一个对象实例时，锁住的是所有以该对象为锁的代码块。

Synchronized的实现原理

它有多个队列，当多个线程一起访问某个对象监视器的时候，对象监视器会将这些线程存储在不同的容器中。

Contention List：竞争队列，所有请求锁的线程首先被放在这个竞争队列中；

Entry List：Contention List中那些有资格成为候选资源的线程被移动到Entry List中；

Wait Set：哪些调用wait方法被阻塞的线程被放置在这里；

OnDeck：任意时刻，最多只有一个线程正在竞争锁资源，该线程被成为OnDeck；

Owner：当前已经获取到所资源的线程被称为Owner；

Owner：当前释放锁的线程。

JVM每次从队列的尾部取出一个数据用于锁竞争候选者（OnDeck），但是并发情况下，ContentionList会被大量的并发线程进行CAS访问，为了降低对尾部元素的竞争，JVM会将一部分线程移动到EntryList中作为候选竞争线程。Owner线程会在unlock时，将ContentionList中的部分线程迁移到EntryList中，并指定EntryList中的某个线程为OnDeck线程（一般是最先进去的那个线程）。Owner线程并不直接把锁传递给OnDeck线程，而是把锁竞争的权利交给OnDeck，OnDeck需要重新竞争锁。这样虽然牺牲了一些公平性，但是能极大的提升系统的吞吐量，在JVM中，也把这种选择行为称之为“竞争切换”。

Synchronized是非公平锁。 Synchronized在线程进入ContentionList时，等待的线程会先尝试自旋获取锁，如果获取不到就进入ContentionList，这明显对于已经进入队列的线程是不公平的，还有一个不公平的事情就是自旋获取锁的线程还可能直接抢占OnDeck线程的锁资源。

Lock锁

synchronized是java底层支持的，而concurrent包则是jdk实现。

公平锁：十分公平，可以先来后到
非公平锁：十分不公平，可以插队（默认）

   
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

package sang.threads;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadDemo1 {
        public static void main(String[] args) {

            threadTest1 test = new threadTest1();
            new Thread(() -> { for (int i = 0; i < 52; i++) test.sale(); },"A").start();
            new Thread(() -> { for (int i = 0; i < 52; i++) test.sale(); },"B").start();
            new Thread(() -> { for (int i = 0; i < 52; i++) test.sale(); },"C").start();
        }
    }

    class threadTest1 {
        Lock lock = new ReentrantLock();
        private int number = 50;
        public void sale(){
            lock.lock();
            try {
                if (number>0) {
                    System.out.println(Thread.currentThread().getName() + "卖出了第：" + (number--) + "张票,还剩：" + number + "张票");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
//找了半天快捷键，结果发现我把方法包括进去了，快捷键： ctrl+alt + t

Synchronized和Lock的区别

Synchronized内置的Java关键字，Lock是一个Java类
Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
Synchronized会自动释放锁，Lock必须要手动释放锁！如果不释放锁，死锁！
Synchronized线程1(获得锁)、线程2(等待，傻傻的等)；Lock就不一定会等待下去
Synchronized可重入锁，不可以中断的，非公平；Lock，可重入锁，可以判断锁，非公平(可以自己设置)
Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)

锁是什么，如何判断锁的是谁！常见的锁

synchronized 关键字锁定代码库
可重入锁 java.util.concurrent.lock.ReentrantLock
可重复读写锁 java.util.concurrent.lock.ReentrantReadWriteLock

可重入锁

指在同一个线程在外层方法获取锁的时候，进入内层方法会自动获取锁。JDK 中基本都是可重入锁，避免死锁的发生。上面提到的常见的锁都是可重入锁。

公平锁 / 非公平锁

公平锁，指多个线程按照申请锁的顺序来获取锁。如 java.util.concurrent.lock.ReentrantLock.FairSync
非公平锁，指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程先获得锁。如 synchronized、java.util.concurrent.lock.ReentrantLock.NonfairSync

独享锁 / 共享锁

独享锁，指锁一次只能被一个线程所持有。synchronized、java.util.concurrent.locks.ReentrantLock 都是独享锁
共享锁，指锁可被多个线程所持有。ReadWriteLock 返回的 ReadLock 就是共享锁

悲观锁 / 乐观锁

悲观锁，一律会对代码块进行加锁，如 synchronized、java.util.concurrent.locks.ReentrantLock
乐观锁，默认不会进行并发修改，通常采用 CAS 算法不断尝试更新
悲观锁适合写操作较多的场景，乐观锁适合读操作较多的场景

粗粒度锁 / 细粒度锁

粗粒度锁，就是把执行的代码块都锁定
细粒度锁，就是锁住尽可能小的代码块，java.util.concurrent.ConcurrentHashMap 中的分段锁就是一种细粒度锁
粗粒度锁和细粒度锁是相对的，没有什么标准

偏向锁 / 轻量级锁 / 重量级锁

JDK 1.5 之后新增锁的升级机制，提升性能。
通过 synchronized 加锁后，一段同步代码一直被同一个线程所访问，那么该线程获取的就是偏向锁
偏向锁被一个其他线程访问时，Java 对象的偏向锁就会升级为轻量级锁
再有其他线程会以自旋的形式尝试获取锁，不会阻塞，自旋一定次数仍然未获取到锁，就会膨胀为重量级锁

自旋锁

自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环占有、浪费 CPU 资源

生产者和消费者问题

生产者和消费者问题 Synchronized版 wait notify

package sang.threads;

public class ATest {
    public static void main(String[] args) {
        Data data = new Data();
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    try {
                        data.increment();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"A").start();
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    try {
                        data.decrement();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"B").start();
        }
}
//判断、等待、通知
class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        if (number != 0) {//判断
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知
        this.notify();
    }
    public synchronized void decrement() throws InterruptedException {
        if (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        this.notify();
    }
}

如果再多两个线程的话就会出现一点问题，可以自己写一下代码测试一下就是虚假唤醒问题

什么是虚假唤醒？

举个例子，我们现在有一个生产者-消费者队列和三个线程。

1） 1号线程从队列中获取了一个元素，此时队列变为空。

2） 2号线程也想从队列中获取一个元素，但此时队列为空，2号线程便只能进入阻塞(cond.wait())，等待队列非空。

3）这时，3号线程将一个元素入队，并调用cond.notify()唤醒条件变量。

4）处于等待状态的2号线程接收到3号线程的唤醒信号，便准备解除阻塞状态，执行接下来的任务(获取队列中的元素)。

5）然而可能出现这样的情况：当2号线程准备获得队列的锁，去获取队列中的元素时，此时1号线程刚好执行完之前的元素操作，返回再去请求队列中的元素，1号线程便获得队列的锁，检查到队列非空，就获取到了3号线程刚刚入队的元素，然后释放队列锁。

6）等到2号线程获得队列锁，判断发现队列仍为空，1号线程“偷走了”这个元素，所以对于2号线程而言，这次唤醒就是“虚假”的，它需要再次等待队列非空。

如果用if判断，多个等待线程在满足if条件时都会被唤醒(虚假的)，但实际上条件并不满足，生产者生产出来的消费品已经被第一个线程消费了。
这就是我们使用while去做判断而不是使用if的原因：因为等待在条件变量上的线程被唤醒有可能不是因为条件满足而是由于虚假唤醒。所以，我们需要对条件变量的状态进行不断检查直到其满足条件，不仅要在线程等待前检查条件是否成立，在线程等待之后也要检查。

解决办法将if改为while

package sang.threads;

public class ATest {
    public static void main(String[] args) {
        Data data = new Data();

            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    try {
                        data.increment();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"A").start();
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    try {
                        data.decrement();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"C").start();
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    try {
                        data.increment();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"B").start();
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    try {
                        data.decrement();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"D").start();
        }
}
//判断、等待、通知
class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
        while (number != 0) {//判断
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知
        this.notify();
    }
    public synchronized void decrement() throws InterruptedException {
        while (number == 0) {
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        this.notify();
    }
}

因为if只会执行一次，执行完会接着向下执行if（）外边的而while不会，直到条件满足才会向下执行while（）外边的

JUC版的生产者和消费者问题

package sang.threads;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BTest {
    public static void main(String[] args) {
        Data1 data = new Data1();

        new Thread(() -> { for (int i = 0; i < 10; i++) data.increment(); },"A").start();
            new Thread(() -> { for (int i = 0; i < 10; i++)  data.decrement();},"C").start();
            new Thread(() -> { for (int i = 0; i < 10; i++) data.increment(); },"B").start();
            new Thread(() -> { for (int i = 0; i < 10; i++) data.decrement(); },"D").start();
        }
    }
    //判断、等待、通知
    class Data1{
        private int number = 0;
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        public void increment(){
            lock.lock();
            try {
                while (number != 0) {//判断
                    //等待
                    condition.await();
                }
                number++;
                System.out.println(Thread.currentThread().getName() + "=>" + number);
                //通知
                condition.signalAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }

        }
        public void decrement() {
            lock.lock();
            try {
                while (number == 0) {

                    condition.await();
                }
                number--;
                System.out.println(Thread.currentThread().getName() + "=>" + number);
                condition.signalAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
              lock.unlock();
            }
        }
    }

任何一个新的技术，绝对不是仅仅只是覆盖原来的技术，优势和补充！

Condition 精准的通知和唤醒线程

package sang.threads;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class CTest {
    public static void main(String[] args) {
        Data2 data2 = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data2.print1();
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data2.print2();
            }
        }).start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                data2.print3();
            }
        }).start();
    }
}
class Data2{
    private int number = 2;
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    public  void print1(){
        lock.lock();
        try {
            while(number != 1) {
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "AAAAAAAA");
            number = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void print2(){
        lock.lock();
        try {
            while(number != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "BBBBBBBB");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print3(){
        lock.lock();
        try {
            while(number != 3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "CCCCCCCC");
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

八锁现象

package sang.threads;

import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {phone.sendInfo();},"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {phone.call();},"B").start();
    }

}
class Phone {
    public synchronized void sendInfo(){
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}
//标准情况下是先执行发短信还是先打印打电话？
//结果：打电话，发短信
//为什么？ 因为有锁的存在
//synchronized 锁的对象是方法的调用者
//两个方法用的是同一个类，谁先拿到谁执行

package sang.threads;

import java.util.concurrent.TimeUnit;
//2.sendInfo延迟4秒，两个线程先发短信还是打电话？1/发短信   2/打电话
//结果：先打短信，在打电话
//被synchronized修饰的方法 锁的对象是方法的调用者
//两个方法用的是同一个类，谁先拿到谁执行
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {phone.sendInfo();},"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {phone.call();},"B").start();
    }

}
class Phone {
    public synchronized void sendInfo(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

现在我们再加一个普通方法不加锁的hello方法，我们再来看一下谁先执行

package sang.threads;

import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Phone1 phone = new Phone1();
        new Thread(() -> {phone.sendInfo();},"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {phone.call();},"B").start();
        new Thread(() -> {phone.hello();},"C").start();
    }

}
    class Phone1 {
        public synchronized void sendInfo(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public synchronized void call(){
            System.out.println("打电话");
        }
        //这里没有锁不是同步方法，不受锁的影响
        public void hello(){
            System.out.println("hello");
        }
    }
//我们发现，先执行的是hello然后是发短信，在然后是打电话

如果在new一个对象出来，会怎么样呢？

package sang.threads;

import java.util.concurrent.TimeUnit;

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Phone1 phone = new Phone1();
        Phone1 phone1 = new Phone1();
        new Thread(() -> {phone.sendInfo();},"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {phone1.call();},"B").start();
        new Thread(() -> {phone.hello();},"C").start();
    }

}
    class Phone1 {
        public synchronized void sendInfo(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public synchronized void call(){
            System.out.println("打电话");
        }
        public void hello(){
            System.out.println("hello");
        }
    }
//我们发现会先执行打电话，然后是hello最后是发短信
//因为有两个对象，所以有两个调用者，所以就是有两个锁，锁不一样

如果将上面的hello线程和打电话线程调换位置调用的话，我们发现先执行hello然后是打电话，再然后是发短信

可以得出结论，因为hello没有锁，所以不受锁的影响，而又有两个对象，是两把不同的锁，所以互相之间也不会受影响，因此，就变成了谁先调用谁先执行。

//我们现在增加两个static方法，还是一样的问题
package sang.threads;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone = new Phone2();
        //Phone2 phone1 = new Phone2();
        new Thread(() -> {phone.sendInfo();},"A").start();
        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {phone.call();},"B").start();
        new Thread(() -> {phone.hello();},"C").start();
        }

    }
    class Phone2 {
        public static synchronized void sendInfo(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public static synchronized void call(){
            System.out.println("打电话");
        }
        public void hello(){
            System.out.println("hello");
        }
    }
//结果就是先执行hello，然后是发短信，最后是打电话
//因为有一个static修饰，static是静态方法，在类一加载就会装载，所以锁的对象是Class，是模板
//Phone2只有唯一的一个Class对象，就是我们发射而得来的那个Class对象，
//锁的是Class，所以才会谁先调用谁先执行

如果现在再增加一个调用者，也就是在增加一个对象，会不会有所不同呢？

答案是不会

package sang.threads;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        //Phone2 phone1 = new Phone2();
        new Thread(() -> {phone1.sendInfo();},"A").start();
        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {phone2.call();},"B").start();
        new Thread(() -> {phone1.hello();},"C").start();
        }

    }
    class Phone2 {
        public static synchronized void sendInfo(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public static synchronized void call(){
            System.out.println("打电话");
        }
        public void hello(){
            System.out.println("hello");
        }
    }
//经过测试我们知道无论增加多少对象都不会对同步代码有影响，因为锁的是Class对象，而Class对象全局唯一

现在我们将方法中的其中一个static去掉，那又会是什么结果呢？

package sang.threads;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone1 = new Phone3();

        new Thread(() -> {phone1.sendInfo();},"A").start();
        TimeUnit.SECONDS.sleep(1);

        new Thread(() -> {phone1.call();},"B").start();
        new Thread(() -> {phone1.hello();},"C").start();
        }

    }
    class Phone3 {
        public static synchronized void sendInfo(){
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        public synchronized void call(){
            System.out.println("打电话");
        }
        public void hello(){
            System.out.println("hello");
        }
    }
//结果是：打电话，hello，发短信
//call（）和hello就不用说了
//这是因为，sendInfo锁的是Class模板，而call锁的是Phone3这个对象，所以有两把锁，互不影响

最后，如果再new一个对象会怎么样呢？

结果是不会有变化的

集合类不安全 List

List 不安全

package sang.Lists;

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

public class ListTest {
    public static void main(String[] args) {
        //并发下ArrayList是不安全的
        List list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

ArrayList()在单线程下是线程安全的，但是在多线程下则是线程不安全的，通过上述代码我们可以发现他会报一个错误java.util.ConcurrentModificationException 并发修改异常

有可能你第一次跑是正常的，你在多跑几次就会发现报这个异常

所以得出并发下ArrayList是不安全的，那怎么解决呢？

先看一下ArrayList的原码

   public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }//底层就是数组

那我们要不要使用synchronized来解决呢？

你以为jdk官方想不到吗？

我们看一下List的版本在看一下Vector的版本



public class Vector
    extends AbstractList
    implements List, RandomAccess, Cloneable, java.io.Serializable
    =========================================================================
public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

我们发现在jdk1.0的时候jdk官方就已经给出了Vector的add方法添加了synchronized的方法，而list是在1.2的时候出的

但这也是一种解决方案

还有一种解决方法就是使用集合的工具类，

package sang.Lists;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;

public class ListTest {
    public static void main(String[] args) {
        List list = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

今天学的是JUC所有亿以JUC也有一种解决方法

package sang.Lists;

import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class ListTest {
    public static void main(String[] args) {
        List list =new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}

我们来看一下CopyOnWriteArrayList的底层是什么

    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
===========================================
      final void setArray(Object[] a) {
        array = a;
    }
=============================================
    
 private transient volatile Object[] array;

我们发现，new出来的CopyOnWriteArrayList在初始化的时候会去调用构造方法，然后调用setArray方法，这个array是由 transient 和volatile 修饰的，所以我们可以猜测，解决的根源就在这两个关键字上，大家可以百度一下这两个关键字，这里不予讲解。

CopyonWritexxx 这个是写入时复制，是一种COW思想，是计算机程序设计的一种优化策略。是提高效率的。

现在存在多个线程调用的时候，资源是相同的，读取到时候是固定的，写入到时候可能会出现覆盖操作，在写入到时候避免覆盖造成数据问题。这就是一种读写分离的思想。

所以：

方案一：List list =new Vector<>();

方案二： List list = Collections.synchronizedList(new ArrayList<>());

方案三：List list =new CopyOnWriteArrayList<>();//JUC包下的工具类就是解决并发问题的

为什么不使用Vector而要使用CopyOnWriteArrayList呢？

看一下Vector的底层

 public Vector() {
        this(10);
    }
 public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
 public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
 private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0) newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

我们可以看到底层是new了一个Object；类型的数组，而且Object初始化长度为10，而add方法则是将数组的的最大索引加一然后又调用ensureCapacityHelper方法进行了一个判断，使用grow方法进行了一系列判断最终使用Arrays.copyOf创建并赋值了一个新数组。

再来看一下CopyOnWriteArrayList的底层代码

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

使用的是lock锁而上面的使用的是synchronized锁，所以要比他效率高一些最终实现的也是Arrays.copyOf方法只是少了许多的判断条件

Set

set和List没多大区别

还是java.util.ConcurrentModificationException线程修改异常这个错

package sang.Lists;

import java.util.HashSet;
import java.util.Set;
import java.util.UUID;

public class SetTest {
    public static void main(String[] args) {
        Set set = new HashSet();
        for (int i = 0; i < 11; i++) {
            new Thread(() -> {
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

解决方案：

1、集合工具类：Set set = Collections.synchronizedSet(new HashSet<>());

2、JUC工具类：Set set = new CopyonWriteArraySet();

HashSet的底层是什么？

就是HashMep

 public HashSet() {
        map = new HashMap<>();
    }
 public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }//add方法就是HashMap的put方法
   private static final Object PRESENT = new Object();
//PRESENT就是个常量

Map

也是不安全的

package sang.Lists;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class MapTest {
    public static void main(String[] args) {
        Map map = new ConcurrentHashMap();
        for (int i = 0; i < 11; i++) {
            new Thread(() -> {
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

解决方案：

1、集合工具类：Map map = Collections.synchronizedMap(new HashMap<>());

2、JUC工具类：Map map = new ConcurrentHashMap();

ConcurrentHashMap是采用分段锁的技术！线程安全！

HashMap的数据结构

HashMap的底层主要是基于数组和链表来实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置。

HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashMap中主要是通过key的hashCode来计算hash值的，只要hashCode相同，计算出来的hash值就一样。如果存储的对象对多了，就有可能不同的对象所算出来的hash值是相同的，这就出现了所谓的hash冲突。

hashMap结构:哈希表是由数组+链表组成的，数组的默认长度为16（可以自动变长。在构造HashMap的时候也可以指定一个长度），数组里每个元素存储的是一个链表的头结点。而组成链表的结点其实就是hashmap内部定义的一个类：Entity。Entity包含三个元素：key，value和指向下一个Entity(实体类)的next

本来想把ConcurrentHashMap的底层逻辑写一下的，但是自己百度了一下，好多概念都不是特别清除，所以不敢写了，里面有红黑树这种数据结构，还有分段锁技术。没几篇文章介绍不清楚。

Callable

Callable接口类似于Runnable ，因为它们都是为其实例可能由另一个线程执行的类设计的。然而，A Runnable不返回结果，也不能抛出被检查的异常。

1、有返回值

2、可以抛出异常

3、方法不同run（） -》 call（）

现在实现一下Callable这个接口

由于Thread（）里面只能放Runnable类型的对象，所以我们Callable要和Runnable挂上钩，所以我们找到了public class FutureTask implements RunnableFuture 他是RunnableFuture的实现类，而RunnableFuture又是public interface RunnableFuture extends Runnable, Future Runnablle的实现类，并且

   public FutureTask(Callable callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

FutureTask的类构造器又可以写入Callable类型的参数，所以我们可以通过FutureTask来开启线程。

package sang.Lists;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask<>(new MyThread());
        new Thread(futureTask,"A").start();
        String s = futureTask.get();//获取Callable的返回值
        System.out.println(s);
    }
}

class MyThread implements Callable {

    @Override
    public String call() throws Exception {
        System.out.println("call()");
        return "12121211";
    }
}//get有可能会产生阻塞，因为它需要获取callable的返回值，所以需要等call运行完成，因此我们将产生阻塞的代码放到最后
//或者使用异步通信来处理

如果在添加一个线程会怎么样呢？

package sang.Lists;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask futureTask = new FutureTask<>(new MyThread());
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();
        String s = futureTask.get();//获取Callable的返回值
        System.out.println(s);
    }
}

class MyThread implements Callable {

    @Override
    public String call() throws Exception {
        System.out.println("call()");
        return "12121211";
    }
}

 protected boolean runAndReset() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return false;
        boolean ran = false;
        int s = state;
        try {
            Callable c = callable;
            if (c != null && s == NEW) {
                try {
                    c.call(); // don't set result
                    ran = true;
                } catch (Throwable ex) {
                    setException(ex);
                }
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
        return ran && s == NEW;
    }

这里的runAndReset，运行方法进行了判断

if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread()))

所以第二次的是没有执行的

常用的辅助类 CountDownLatch

```
public class CountDownLatch
extends Object
```
允许一个或多个线程等待直到在其他线程中执行的一组操作完成的同步辅助。

A CountDownLatch用给定的计数初始化。 await方法阻塞，直到由于countDown()方法的调用而导致当前计数达到零，之后所有等待线程被释放，并且任何后续的await 调用立即返回。这是一个一次性的现象 - 计数无法重置。如果您需要重置计数的版本，请考虑使用CyclicBarrier 。

A CountDownLatch是一种通用的同步工具，可用于多种用途。一个CountDownLatch为一个计数的CountDownLatch用作一个简单的开/关锁存器，或者门：所有线程调用await在门口等待，直到被调用countDown()的线程打开。一个CountDownLatch初始化N可以用来做一个线程等待，直到N个线程完成某项操作，或某些动作已经完成N次。

CountDownLatch一个有用的属性是，它不要求调用countDown线程等待计数到达零之前继续，它只是阻止任何线程通过await ，直到所有线程可以通过。

（不知道为什么这里截图不好使了1，这是在jdk文档上复制的）
```
   //CountDownLatch源码中的构造1器，需要填一个int类型的参数
public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }
  Sync(int count) {
            setState(count);
        }
 protected final void setState(int newState) {
        state = newState;
    }
    private volatile int state;
    private final Sync sync;
```

一般用在某些必须执行完成的线程内，保证线程的安全

package sang.Lists;

import java.util.concurrent.CountDownLatch;

//计数器
public class CountDownLatchDome {
    public static void main(String[] args) throws InterruptedException {
        //倒计时，总数是6
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "Get out!");
                countDownLatch.countDown();//倒计时，-1
            },String.valueOf(i)).start();
        }
       countDownLatch.await();//等待计数器归零
        System.out.println("Close the Door!");

    }
}

CyclicBarrier

加法计数器

```
public class CyclicBarrier
extends Object
```
允许一组线程全部等待彼此达到共同屏障点的同步辅助。循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。屏障被称为循环，因为它可以在等待的线程被释放之后重新使用。

A CyclicBarrier支持一个可选的Runnable命令，每个屏障点运行一次，在派对中的最后一个线程到达之后，但在任何线程释放之前。在任何一方继续进行之前，此屏障操作对更新共享状态很有用。

可以简单理解为加法计数器

    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }
  public CyclicBarrier(int parties) {
        this(parties, null);
    }
//CyclicBarrier的构造方法有两个，只放一个参数就是简单地加法倒计时，第二个参数可以放置一个Runnable类型的类
//所以我们在后面添加一个Lamda表达式

package sang.Lists;

import java.sql.Time;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;

public class CyclicBarrierDemo {
    public static void main(String[] args) throws InterruptedException {
        //集齐七科龙珠召唤神龙
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,() -> {

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("召唤神龙成功！！！");
        });
        for (int i = 1; i < 8; i++) {
            final int j = i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "集齐了" + j + "颗龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

        TimeUnit.SECONDS.sleep(1);
        System.out.println("谁先执行？");
    }
}

有点意思，自己探索吧！

Semaphore(信号量)

一个计数信号量
在概念上，信号量维持一组许可证。
如果有必要，每个acquire()都会阻塞，直到许可证可用，然后才能使用它。
每个release()添加许可证，潜在地释放阻塞获取方。
但是，没有使用实际的许可证对象; Semaphore只保留可用数量的计数，并相应地执行。
信号量通常用于限制线程数，而不是访问某些（物理或逻辑）资源

package sang.Lists;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 7; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "我进去了！");
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName() + "我又出去了！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {

                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

原理
semaphore.acquire();获取，假设已经满了，等待被释放为止！
semaphore.release();释放，会将当前的信号量释放+1，然后唤醒等待的线程
作用：多个共享资源互斥的使用！并发限流，控制最大的线程数！

读写锁 ReadWriteLock

A ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。 write lock是独家的。

也就是说，读可以由多个线程去读，写只能有一个线程去写

package sang.Lists;

import java.util.HashMap;
import java.util.Map;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 7; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(String.valueOf(temp),String.valueOf(temp));
            },String.valueOf(i)).start();
        }

        for (int i = 0; i < 7; i++) { 
            final int temp = i;
            new Thread(() -> {
                myCache.get(String.valueOf(temp));
            },String.valueOf(i)).start();
        }
    }
}


class MyCache{
    private Map map = new HashMap<>();

    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName() + "写入" + key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + "写入完成!");
    }

    public void get(String key){
        System.out.println(Thread.currentThread().getName() + "开始读取" + key);
        map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取完成");
    }
}

加一下锁

package sang.Lists;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for (int i = 0; i < 7; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(String.valueOf(temp),String.valueOf(temp));
            },String.valueOf(i)).start();
        }

        for (int i = 0; i < 7; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.get(String.valueOf(temp));
            },String.valueOf(i)).start();
        }
    }
}


class MyCache{
    private Map map = new HashMap<>();
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "写入" + key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName() + "写入完成!");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void get(String key){
        readWriteLock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName() + "开始读取" + key);
            map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}//如果不加读锁的话会产生一点小问题，大家可以自己测试一下

独占锁(写锁)一次只能有一个线程占有

共享锁(读锁)一次可以有多个线程占有

阻塞队列

BlockingQueue阻塞队列不是一个新东西，我们可以从下图可看出了

什么情况下我们会使用阻塞队列：多线程并发处理，线程池！

package sang.Lists;

import java.util.Collection;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;

public class BlockQueueDemo {
    public static void main(String[] args) {
        BlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        System.out.println(blockingQueue.add("d"));
    }
}
=======================================================
    true
true
true
Exception in thread "main" java.lang.IllegalStateException: Queue full
	at java.util.AbstractQueue.add(AbstractQueue.java:98)
	at java.util.concurrent.ArrayBlockingQueue.add(ArrayBlockingQueue.java:312)
	at sang.Lists.BlockQueueDemo.main(BlockQueueDemo.java:15)

Process finished with exit code 1

四组API

1、抛出异常

 //抛出异常
    public static void test1(){
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(arrayBlockingQueue.add("A"));
        System.out.println(arrayBlockingQueue.add("B"));
        System.out.println(arrayBlockingQueue.add("C"));
        //IllegalStateException: Queue full 。
        //System.out.println(arrayBlockingQueue.add("D"));
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.element());//检查队首元素
        System.out.println(arrayBlockingQueue.remove());
        //.NoSuchElementException ,抛出异常
        //System.out.println(arrayBlockingQueue.remove());
    }

2、不会抛出异常

   public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }
 public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

//有返回值不会抛出异常
    public static void test2(){
        ArrayBlockingQueue

多线程之JUC

Java相关栏目本月热门文章