JUC初阶学习

JUC学习大纲

前言

hi，大家好，此篇笔记是作者通过观看狂神说JUC并且自己查阅一些资料编辑完成的JUC学习笔记，大家可以观看目录查找自己想要了解的问题，会不定时更新补充，欢迎大家阅读收藏！！

---

1、回顾进程线程与并发并行

1、进程与线程

java真的可以开启线程吗？不可以

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}
//native 本地方法，调用底层的c++来操作硬件。java无法直接操作硬件
private native void start0();

2、并发与并行

//获取cpu的核数
System.out.println(Runtime.getRuntime().availableProcessors());

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

1、线程有几个状态

public enum State {
    //创建态
    NEW,
    
	//运行态
    RUNNABLE,
    
    //阻塞态
    BLOCKED,
    
    //等待态，会一直等下去
    WAITING,
    
    //超时等待，等一段时间
    TIMED_WAITING,

    //终止态
    TERMINATED;
}

2、wait/sleep的区别

1、来自不同的类

wait => Object

sleep => Thread

2、关于锁的释放

wait 会释放锁

sleep 不会释放

3、使用的范围是不同的

wait 必须在同步代码块中使用

sleep 可以在任何地方使用

2、Lock锁☆！！！！

1、传统Synchronized

//基本的卖盘例子
/*
* 公司开发中，降低耦合性
* 线程就是一个单独的资源类，没有任何附属的操作！！！
* 1、属性、方法
* */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();

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

//资源类  oop编程
class Ticket{
    //属性  方法
    private int num=50;

    //synchronized 本质：队列，锁
    public synchronized void sale(){
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票，剩余："+num+"张票");
            System.out.println();
        }
    }
}

2、JUC中的lock锁

是一个接口，具有三个实现类

ReentrantLock  可重入锁（最常用的）
ReadLock 读锁
WriteLock 写锁

ReentrantLock

public ReentrantLock() {
    //如果无参就为非公平锁
    sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
    //如果为true，则为公平锁
    sync = fair ? new FairSync() : new NonfairSync();
}

公平锁：先来先服务

非公平锁：可以抢占资源（默认）

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        Ticket1 ticket=new Ticket1();

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

//资源类  oop编程
class Ticket1{
    private int num=50;

    Lock lock = new ReentrantLock(true);

    public void sale(){
        try{
            lock.lock();
            if(num>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票，剩余："+num+"张票");
                System.out.println();
            }
        }finally {
            lock.unlock();
        }

    }
}

3、传统Synchronized与lock锁的区别

1、Synchronized 内置的 java 关键字，Lock锁是一个类

2、Synchronized 无法判断获取锁的状态，Lock 锁可以判断是否获取到了锁

3、Synchronized 会自动释放锁，lock 必须要手动释放锁！！如果不释放锁，会造成死锁问题

4、Synchronized 线程1（获得锁）的话，线程2会一直等待，如果线程1（阻塞），线程2还是会一直等待；lock锁就不一定会等待下去

lock.tryLock();

5、Synchronized 可重入锁，不可中断，非公平的；lock，可重入锁，可以判断锁，可以自己设置公平锁。

Lock lock = new ReentrantLock(true);//公平锁
Lock lock = new ReentrantLock();//非公平锁

6、Synchronized 适合锁少量的代码同步问题，lock 锁适合锁大量的同步代码。

3、生产者与消费者问题

public class A {
    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();
                }
            }
        },"生产者").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.reduce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者1").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.reduce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者2").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者2").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.notifyAll();
    }

    public synchronized void reduce() throws InterruptedException {
        if(number == 0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }

}

1、虚假唤醒问题解决

上述代码A、B、C、D四个线程，会产生虚假唤醒

为了解决这个问题，我们需要将if判断改为while

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.notifyAll();
    }

    public synchronized void reduce() throws InterruptedException {
        while (number == 0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        this.notifyAll();
    }
}

2、JUC版本的生产者与消费者问题

1、synchronized与lock 对线程阻塞与唤醒的不同

synchronized： 	
	wait()//阻塞当前资源	
	notify()//随机唤醒一个资源	
	notifyAll()//唤醒所有资源
Lock：	
	await()//阻塞当前资源	
	signal()//唤醒当前资源	
	signalAll()//唤醒所有资源

public class B {
    public static void main(String[] args) {
        Data1 data=new Data1();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.reduce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者1").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.reduce();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者2").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者2").start();
    }
}
class Data1{
    private int number=0;
    Lock lock=new ReentrantLock();
    Condition condition = lock.newCondition();
    public void increment() throws InterruptedException {
        try {
            lock.lock();
            while (number != 0){
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        }finally {
            lock.unlock();
        }

    }

    public void reduce() throws InterruptedException {
        try {
            lock.lock();
            while (number == 0){
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

上述代码执行出的结果是随机的，如果想要让进程进行有序的执行的话可以使用Condition 进行精准的通知和唤醒线程。

具体操作：

public class C {
    public static void main(String[] args) {
        //A 执行完调用B，B执行完调用C，C执行完调用A
        Data2 data=new Data2();
        new Thread(()->{
            for (int i=0;i<10;i++){
                data.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                data.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                data.printC();
            }
        },"C").start();
    }
}
class Data2{
    private int number=1;
    private Lock lock=new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    //业务：判断-> 执行-> 通知
    public void printA(){
        try {
            lock.lock();
            while (number!=1){
                //等待
                try {
                    condition1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAA");
            //唤醒指定的人B
            number=2;
            condition2.signal();

        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        try {
            lock.lock();
            while (number!=2){
                try {
                    condition2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBB");
            number=3;
            condition3.signal();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        try {
            lock.lock();
            while (number!=3){
                try {
                    condition3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCC");
            number=1;
            condition1.signal();
        }finally {
            lock.unlock();
        }
    }


}

运行结果：

4、8锁现象

如何判断锁的是谁！！知道什么是锁，锁的是谁。

通过以下问题了解到什么是锁。

1、使用两个synchronized锁方法时，先执行哪个方法？

public class A {    
    /*    这个代码运行结果是 1、发短信 2、打电话    原因并不是因为因为 A先执行的，而是因为锁的存在         */    
    public static void main(String[] args) {        
    Phone phone=new Phone();//    由于两个方法用的同一个锁，所以谁先拿到谁先执行        
        new Thread(()->{ phone.senSms(); },"A").start();        
        try 
        {            
            TimeUnit.SECONDS.sleep(1);//阻塞一秒钟        
            } catch (InterruptedException e) {            
            e.printStackTrace();        
        }        
        new Thread(()->{ phone.call(); },"B").start();    
    }
}
class Phone{
    //    synchronized  锁的对象是方法的调用者    
    public synchronized void senSms(){        
        System.out.println("发短信");    
    }    
    public synchronized void call(){        
        System.out.println("打电话");    
    }
}

2、使用synchronized并且调用普通方法时，是先执行发短信还是hello？

public class A {
    /*
    这个代码运行结果是 1、hello 2、发短信
    原因：hello方法不是同步方法，不受锁的影响
     */
    public static void main(String[] args) {
        Phone phone=new Phone();
        new Thread(()->{ phone.senSms(); },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{ phone.hello(); },"B").start();
    }
}
class Phone{
//    synchronized  锁的对象是方法的调用者
    public synchronized void senSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call(){
        System.out.println("打电话");
    }
    
    //没有锁，不是同步方法，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

3、两个对象，两个同步方法，先执行发短信还是打电话？

public class A {
    /*
    这个代码运行结果是 1、打电话 2、发短信
    原因：由于两个方法用的不是同一个锁
     */
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁
        Phone phone1=new Phone();
        Phone phone2=new Phone();
        new Thread(()->{ phone1.senSms(); },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{ phone2.call(); },"B").start();
    }
}
class Phone{
//    synchronized  锁的对象是方法的调用者
    public synchronized void senSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"发短信");
    }

    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"打电话");
    }

    //没有锁，不是同步方法，不受锁的影响
    public void hello(){
        System.out.println(Thread.currentThread().getName()+"hello");
    }
}

4、使用static修饰的synchronized方法，一个对象先执行哪个方法？

public class B {    public static void main(String[] args) {        //一个对象        
    Phone1 phone1=new Phone1();        
    new Thread(()->{ phone1.senSms(); },"A").start();        
    try {            
        TimeUnit.SECONDS.sleep(1);        
    } catch (InterruptedException e) {            
        e.printStackTrace();        
    }        
    new Thread(()->{ phone1.call(); },"B").start();    }
}
class Phone1{    
    //static 类一加载就有了，锁的是Class模板    
    //因为两个方法都被static修饰了，所以使用的是同一个锁    
    public static synchronized void senSms(){
        try {
            TimeUnit.SECONDS.sleep(2);        
        } catch (InterruptedException e) { 
            e.printStackTrace();      
        }
        System.out.println(Thread.currentThread().getName()+"发短信");   
    }    
    public static synchronized void call(){      
        System.out.println(Thread.currentThread().getName()+"打电话"); 
    }
}

5、使用static修饰的synchronized方法，两个对象先执行哪个方法？

public class B {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁，
        //因为是使用的static方法，所以使用的都是一个Class对象，所以先执行A，在B
        Phone1 phone1=new Phone1();
        Phone1 phone2=new Phone1();
        new Thread(()->{ phone1.senSms(); },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{ phone2.call(); },"B").start();
    }
}

class Phone1{

    //static 类一加载就有了，锁的是Class模板
    //因为两个方法都被static修饰了，所以使用的是同一个锁
    public static synchronized void senSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"发短信");
    }

    public static synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"打电话");
    }
}

6、一个方法使用static synchronized，一个使用普通synchronized，创建一个对象，调用两个方法谁先执行？

public class C {
    public static void main(String[] args) {
        //此方法类似于创建两个对象，使用不同的锁，所以是b先运行，a最后
        Phone2 phone1=new Phone2();
        new Thread(()->{ phone1.senSms(); },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{ phone1.call(); },"B").start();
    }
}

class Phone2{
    //static 类一加载就有了，锁的是Class模板
    //一个静态synchronized锁，一个普通的synchronized锁
    public static synchronized void senSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"发短信");
    }

    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"打电话");
    }
}

7、一个方法使用static synchronized，一个使用普通synchronized，创建两个对象，分别调用两个方法谁先执行？

public class C {    
    public static void main(String[] args) {        
        //因为是使用的static方法，所以使用的都是一个Class对象        
        //而因为call方法没有使用static，所以锁所属对象不是Class，所以B先执行   
        Phone2 phone1=new Phone2();   
        Phone2 phone2=new Phone2();    
        new Thread(()->{ phone1.senSms(); },"A").start();   
        try {       
            TimeUnit.SECONDS.sleep(1);     
        } catch (InterruptedException e) {   
            e.printStackTrace();    
        }       
        new Thread(()->{ phone2.call(); },"B").start();    
    }
}
class Phone2{
    //static 类一加载就有了，锁的是Class模板 
    //一个静态synchronized锁，一个普通的synchronized锁
    public static synchronized void senSms(){ 
        try {
            TimeUnit.SECONDS.sleep(2);   
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println(Thread.currentThread().getName()+"发短信");  
    }
    public synchronized void call(){ 
        System.out.println(Thread.currentThread().getName()+"打电话");   
    }
}

8、两个使用static的同步方法，分别在不同的类中，如果同时调用相同的方法，谁先开始执行？

public class C {    
    public static void main(String[] args) {        
        //因为是使用的static方法，所以使用的都是一个Class对象，所以先执行A，在B   
        Phone2 phone1=new Phone2(); 
        Phone3 phone2=new Phone3();   
        new Thread(()->{ phone1.call(); },"A").start(); 
        try {      
            TimeUnit.SECONDS.sleep(1);   
        } catch (InterruptedException e) { 
            e.printStackTrace();      
        }     
        new Thread(()->{ phone2.call(); },"B").start();   
    }
}
class Phone2{ 
    public synchronized void call(){     
        try {    
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {    
            e.printStackTrace();    
        }  
        System.out.println(Thread.currentThread().getName()+"打电话");
    }
}
class Phone3{  
    public static synchronized void call(){      
        System.out.println(Thread.currentThread().getName()+"打电话");   
    }
}

9、总结

new this 具体的一个类，也就是说你创建多个对象的话，每个对象的锁互不相关，对象在调用同步方法时，并不会阻塞其他对象调用其他方法。

static Class 唯一的一个模板，如果在同步方法上添加static字段，这个静态同步方法在被调用时，会自己通过反射调用一个Class模板，生成一个当前类static同步方法通用的锁。

5、集合类不安全

1、List 不安全

public class List1 {
    //java.util.ConcurrentModificationException 并发修改异常！！
    //当我们直接使用ArrayList进行并发操作时，会产生并发修改异常。
    public static void main(String[] args) {
        //在并发下，ArrayList是不安全的
        List<Object> 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 的线程不安全问题，我们有以下解决方法：

public class List1 {
        //java.util.ConcurrentModificationException 并发修改异常！！
    public static void main(String[] args) {
        //在并发下，ArrayList是不安全的
        /*
        * 解决方案:
        * 1、使用Vector 去解决并发安全问题
        * List