深入浅出JUC并发编程

时间:2020-9-16 作者:admin

前言:此篇文章是为了写出一些我对多线程的理解,可能没有涉及到太多的AQS等底层实现原理,但是如果花时间来阅读的话,也会有很大的收获的!

多线程

进程和线程

进程:一个程序

一个进程可以包含多个线程,至少包含一个

线程:是一个单独的资源类

Java默认有几种线程

默认是两个,一个是GC垃圾回收和main方法线程

线程的几种状态

·新建(NEW)

线程对象一旦创建就会进入到新生状态

·就绪(Runnable)

当调用start()方法,线程立即进入就绪状态,但不意味着立刻调度执行

·运行(Running)

进入运行状态,线程会自动调用run方法,进行一个运行状态.

·阻塞(Blocked)

当调用sleep,wait或同步锁定时,线程进入阻塞状态,就是代码不往下执行,阻塞事件解除后,重新进入就绪状态,等待cpu调度执行

·死亡(DEAO)

线程中断或者结束,一旦进入死亡状态,就不能再次启动

wait/sleep区别

1.不同的类 wait是object类 sleep是Thread类

2.锁的释放

wait会释放锁,sleep不会释放

3.使用的范围

wait必须在同步代码块中使用(得有一个人等)

sleep可以在任何地方

什么是守护线程

线程分为用户线程和守护线程,守护线程为用户线程提供公共服务,在没有用户线程可服务就会自动离开.

守护线程的优先级

优先级比较低,用于为系统中的对象和线程提供服务

如何设置守护线程

通过SetDaemon(true)设置为”守护线程”

生命周期

于线程同生共死,当守护的线程死亡,守护线程也就死亡

虚拟机必须确保用户线程执行完毕:列如 main主线程

虚拟机不用等待守护线程执行完毕 :列如 GC线程

线程同步

什么是synchronized?

多个线程同时访问同一个数据,带来方便的同时,也带来了访问冲突问题,我们要保证线程同步互斥,也就是指并发执行的多个线程,变成在同一时间内只允许一个线程访问共享资源,在访问时加入同步锁synchronized,当一个线程获得锁,独占资源,其他线程必须等待,使用后释放锁.

存在问题

1.一个线程持有锁会导致其他所有需要此锁的线程挂起。

2.在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题。

3.如果一个优先级高得线程等待一个优先级低得线程释放锁,会导致优先级倒置,引发性能问题

synchronized同步方法

 public synchronized void   caoyuzheng(){
       //同步方法
    }

Synchronized块

synchronized(obj){}//同步代码块

我们这里插入一个Synchronized实现卖票的一个例子

package com.cao.demo1;

/**
 * @Author 癔症
 * @Date 2020/8/18 10:52
 * @Version 1.0
 */
/**
 *基本的卖票例子
 * 真正的多线程开发,公司中的开发,降低耦合性
 * 线程就是一个单独的资源类,没有任何附属的操作!
 */
public class SynchronizedDemo {
    public static synchronized void main(String[] args) {
        Ticket ticket = new Ticket();
       //函数式接口 @FunctionalInterface jdk1.8 lambad表达式   (参数)->{代码} 减少了大量的代码,最大的有点是解决了程序之间的耦合性
        new  Thread(()->{
            for(int i=0;i<40;i++){
                ticket.sale();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new  Thread(()->{
            for(int i=0;i<40;i++){
                ticket.sale();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

        new  Thread(()->{
            for(int i=0;i< 40;i++){
                ticket.sale();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

    }

}
class   Ticket{
    //属性,方法
    private int num=50;
    //卖票的方式
    public synchronized void   sale(){
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(num--)+"票"+"剩余票数"+num);
        }
    }
}

Synchronized在1.6版本之前一直都是处于一个重量级锁,但是它在1.6版本之后做了很大的更改,也就是所谓的锁升级!

锁升级

无锁状态,到它的偏向锁,再到它的一个轻量级锁,最后到重量级锁

偏向锁

一般在偏向锁的情况下,它就偏向于获得第一个锁的线程,它会将线程拉到这个锁对象的对象头当中,当其他线程来的时候,它可能就会立刻结束这个偏向状态,进而跑到一个轻量级锁,

轻量级锁

在低并发情况下来消除锁的源于,它主要是在虚拟栈中开辟一个空间叫Lock Record,将锁对象的Make word 写入,再尝试将另一个Lock Record的指针,使用CAS去修改锁对象头的那个区域,完成一个加锁过程,它也是普遍应用于一个低并发的情况,再往上如果锁竞争非常激烈。那就会立刻升级为一个重量级锁.

重量级锁

用的是一个互斥锁的过程,通过对象内部的监视器(monitor)实现,而其中 monitor 的本质是依赖于底层操作系统的 Mutex Lock 实现,操作系统实现线程之间的切换需要从用户态切换到内核态,切换成本非常高.重量级锁的话,同步方法和同步代码块不一样的!

同步代码块(重量级锁)

在编译之后,会在你的代码前后加上两个指令,一个是mointerenter,一个是mointerexit,一个线程来的时候,它发现它的锁标志位是无锁,是01状态,它会尝试给一个互斥锁对象,锁对象的时候会跟另一个对象关联,就是监视器monitor,它会在monitor的一个锁定器加1.并且将这个monitor的指针写入到一个对象头中表示,并且修改它的锁对象标志位为1 0,就是它重量级锁的一个标志位,以此完成换锁的过程,并且它在这个过程是可重入的,因为它不会每次出去之后,再进来需要加锁和释放锁,它每次进来后获取这个锁,让锁记录加1即可,它加锁完之后,当其他线程来的时候,它会检查到这个锁对象头中,monitor监视器锁上计数器不为0,它会在monitor监视状态下等待去竞争这个锁,如果之前的操作结束,它就退出开始释放这锁,并且逐步的将加上的锁定释放几次,将计数器清零来完成对锁的一个释放.让其他线程继续去竞争这个锁,这是它重量级锁同步代码块的一个原理.

同步方法(重量级锁)

同步方法的话,它就不是这种指令了,而是ACC_SYNCHRONIZED标志位,相当于一个flag,当JVM去检测到这样一个flag,它自动去走了一个同步方法调用的策略,这个原理是比较简单的.

锁升级一般不会降级

简单来说就是锁会由它锁竞争的强度而升级.
锁降级基本上就是进入gc的时候了,所以基本不考虑锁降级.
深入浅出JUC并发编程

Lock锁

ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显示加锁、释放锁

深入浅出JUC并发编程
深入浅出JUC并发编程

深入浅出JUC并发编程

ReentrantLock默认使用非公平锁

默认是使用的非公平锁,为什么,因为是为了保证公平的,为什么保证公平,假如我前面有个线程执行的时间会很花费很长时间,但是后面的线程花费及其少的时间,它就会插队,保证公平,我们可以在里面填入参数true改编成公平锁

Lock锁同步代码的实现

package com.cao.demo1;

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

/**
 * @Author 癔症
 * @Date 2020/8/18 13:26
 * @Version 1.0
 */
public class LockDemo {
    public static  void main(String[] args) {
        Ticket ticket = new Ticket();
          new Thread(()->{
              for(int i=0;i<40;i++) { ticket.sale();
              }
          },"A").start();
        new Thread(()->{
            for(int i=0;i<40;i++) { ticket.sale();
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<40;i++) { ticket.sale();
            }
        },"C").start();
}
//Lock锁三部曲
    //1.new  ReentrantLock();
    //2.加锁, 使用.lock();
    //3.解锁, finally-->.unlock();
class   Ticket2{
    //属性,方法
    private int num=50;

       Lock  lock=new ReentrantLock();
    public  void   sale(){
        //加锁

        lock.lock();
        try {
          //业务代码
            if(num>0){
                System.out.println(Thread.currentThread().getName()+"卖出了"+(num--)+"票"+"剩余票数"+num);
                lock.tryLock();//查看锁的状态
            }
      }catch (Exception e){
      }finally {
          //解锁
           lock.unlock();
      }

    }
}
}

公平锁/非公平锁

公平锁:十分共平,保证线程之间可以条条有序
举例来说如果我前面一条线程执行需要30秒,而另一条线程执行需要3秒,但是3秒的还是会要等待30秒的执行完.

非公平锁:十分不公平,线程之间可以进行一个插队操作!
举例来说如果我前面一条线程执行需要30秒,而另一条线程执行需要3秒,但是3秒的线程会提前执行,30秒的后执行.

synchronized和lock的区别

1.Synchronized 无法判断获取锁的状态,lock可以获取锁的状态
深入浅出JUC并发编程

2.Synchronized 会自动释放锁,lock必须手动释放锁!如果不释放,会出现死锁.

3.Synchronized 线程需要释放锁才能进行执行下一个线程,假如出现阻塞会一直等待,lock锁不一定会等待下去,因为它可以获取锁的状态

4.Synchronized 可重入锁,不可以中断的,非公平;lock锁可重入锁,可以判断锁,非公平(可自动进行设置)

ReentrantLock和Synchronized 的区别

1.synchronized是JVM的一个关键字,ReentrantLock其实就是一个类,你需要去手动去编码.

2.synchronized在使用的时候比较简单,直接同步代码块或者直接同步方法,不需要关心锁的释放,但是ReentrantLock需要手动的去lock然后配合try finally代码块一定要去把它的锁给释放

3.ReentrantLock相比synchronized有几个高级特性,它提供了一个,如果一个线程长期等待不到一个锁的时候,为了防止死锁,可以去手动调用lockInterruptibly方法,尝试去释放这个锁,释放自己的资源不去等待

4.ReentrantLock提供了一个,可以构造公平锁的一个方式,因为它的构造函数有一个但是不推荐使用,因为它会让ReentrantLock等级下降,它提供了一个condition,可以指定去唤醒绑定到condition身上的线程,来实现选择性通知的一个机制.

关于选择性,如果不需要ReentrantLock的特性的话,还是使用synchronized,因为相比来说synchronized的话,它是JVM层面的关键字,当优化JDK的时候它会非常方便的去了解,当前的锁被那些线程所持有,这个状态的话不是ReentrantLock能相比的,还是synchronized比较好些

死锁

某一个同步块同时拥有两个以上对象的锁时,就可能发生死锁问题.

产生死锁的四个必要条件

\1. 互斥条件:一个资源每次只能被一个进程使用。

\2. 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放.

\3. 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺.

\4. 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系.

死锁避免

破任意一个或多个条件就可以避免死锁,同步中尽量不要嵌套同步

死锁排查

1.我们可以使用jps -l来查看所有线程号

2.然后使用jstack查看所有线程号

如果报出异常,说明此线程出现了死锁,这种方法主要是通过日志和堆栈信息来确定的.

当然也可以使用工具来排查,这里就省略不说了.

并发保证集合安全

CopyOnWriteArrayList

CopyOnWriteArrayList解决并发ArrayList不安全问题

并发下ArrayList是不安全的

解决方案:
1、使用Vector

2、Collections.synchronizedList转换安全 转换的synchronized

3、使用 CopyOnWriteArrayList

CopyOnWriteArrayList写入时复制,计算机程序设计领域的一种优化策略

多个线程调用的时候,list 读取的时候,固定的 写入(覆盖).

在写入的时候避免覆盖,造成数据问题

读写分离

CopyOnWriteArrayList 跟Vector 的区别

CopyOnWriteArrayList 比Vector 效率要高,因为CopyOnWriteArrayList 在Add的时候底层没有使用同步锁来实现,Vector在Add的时候底层使用了使同步锁来实现,使用同步锁实现效率会比较低.

CopyOnWriteArraySet

并发下Set是不安全的

解决方案

1、Collections.synchronizedList转换安全 转换的synchronized

2、使用CopyOnWriteArraySet

补充知识:HashSet底层实现原理

//HashSet底层是使用HashMap实现的
public HashSet() {
        map = new HashMap<>();
    }          
//添加时就单纯一个put  key是无法重复的
public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

//PRESENT就是一个常量固定值
 private static final Object PRESENT = new Object();

并发下hashMap是不安全的
1.使用ConcurrentHashMap代替来保证一个线程安全
2.放进Collection.Synchronized中来保证线程安全.

CountDownLatch

它适合一个线程等待一批线程达到一个同步点,之前进去就行

它的计数器是不能重用的

减法计数器,

package aadd;

import java.util.concurrent.CountDownLatch;

/**
 * @Author 癔症
 * @Date 2020/8/26 20:47
 * @Version 1.0
 */
//计数器
public class CoutDownlatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //总数是6 ,必须要执行任务的时候使用
        CountDownLatch downlatch = new CountDownLatch(6);
        for(int i=1;i<=6;i++){
         new  Thread(()->{
             System.out.println(Thread.currentThread().getName()+"Go out");
         downlatch.countDown();//数量-1
         },String.valueOf(i)).start();
        }
        downlatch.await();//等待计数器归零,然后向下执行
        System.out.println("关闭");
    }

}

原理:

countDown(); 数量-1

await(); 等待计数器归零

CyclicBarrier

它是一批线程同时到达一个临界点,之后再往下走

它的计数器是可以留下来的

加法计数器

package aadd;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @Author 癔症
 * @Date 2020/8/26 21:00
 * @Version 1.0
 */
public class CyclicBarrierDemo{
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召唤神龙");
        });
        for(int i=1;i<=7;i++){
            final  int temp =i;
     new Thread(()->{
         System.out.println(
                 Thread.currentThread().getName()+"收集"+temp+"个龙珠"
         );
         try {
             cyclicBarrier.await();//等待
         } catch (InterruptedException e) {
             e.printStackTrace();
         } catch (BrokenBarrierException e) {
             e.printStackTrace();
         }
     }).start();
        }
    }
}

Semaphore

它就是我们经常称谓的信号量,它可以维持一组许可证

package aadd;

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

/**
 * @Author 癔症
 * @Date 2020/8/26 21:12
 * @Version 1.0
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
      
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i <=6 ; i++) {
           new  Thread(()->{
              
               try {
                   semaphore.acquire();
                   System.out.println(Thread.currentThread().getName()+"抢到车位");
                   TimeUnit.SECONDS.sleep(2);
                   System.out.println(Thread.currentThread().getName()+"离开车位");
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }finally {
                   semaphore.release();
               }
            
           },String.valueOf(i)).start();
        }

    }
}

原理:

acquire();//获取,假设如果已经满了,等待,等待被释放为止!

release(); //释放,会将当前的信号量释放+1.然后唤醒等待的线程!

作用:多个共享资源互斥的作用!并发限流,控制最大的线程数!

读写锁

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

共享锁(读锁):多个线程可以同时占有

ReadwriteLock

写入的时候,只希望同一个线程去写

writeLock.lock方法

读取的时候所有人都可以读!

readLock.lock方法

这个时候其实我们已经不知不觉看到了很多锁了.其实锁并没有太难!!!
接下来我们再来聊聊队列,为线程池打一个铺垫!!!
深入浅出JUC并发编程

阻塞队列

BlockingQueue

写入:如果队列满了,就必须阻塞等待

取:如果是队列是空的,必须阻塞等待生产.

深入浅出JUC并发编程
什么情况下会使用阻塞队列:多线程并发处理,线程池!

方式 抛出异常 有返回值 阻塞等待 超时等待
添加 add offer put offer
移除 remove poll take poll
判断队列首 element peek
//第一种抛出异常
package bq;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * @Author 癔症
 * @Date 2020/8/27 15:45
 * @Version 1.0
 */
public class Test {
    public static void main(String[] args) {
       Test1();
    }

    public static void Test1(){
        //队列的大小
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        System.out.println( queue.add("a"));
        System.out.println( queue.add("b"));
        System.out.println( queue.add("c"));
        //java.lang.IllegalStateException: Queue full
        //System.out.println( queue.add("d"));

        //java.util.NoSuchElementException
        //System.out.println(queue.remove());
        System.out.println(queue.remove());
        System.out.println(queue.remove());
        System.out.println(queue.remove());
    }

}
//第二种不抛出异常
package bq;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * @Author 癔症
 * @Date 2020/8/27 15:45
 * @Version 1.0
 */
public class Test {
    public static void main(String[] args) {
       Test2();
    }

    
    public static void Test2(){
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);

        System.out.println(queue.offer("a"));
        System.out.println(queue.offer("b"));
        System.out.println(queue.offer("c"));
        //超出长度。不抛出异常
        //System.out.println(queue.offer("d"));

        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        //移除超出长度,返回null
        //System.out.println(queue.poll());

    }

}

//第三种阻塞等待
package bq;

import java.util.concurrent.ArrayBlockingQueue;

/**
 * @Author 癔症
 * @Date 2020/8/27 15:45
 * @Version 1.0
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {
       Test3();
    }

  
    public static void Test3() throws InterruptedException {
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        queue.put("a");
        queue.put("b");
        queue.put("c");
        //队列没有位置了,一直阻塞
       // queue.put("d");


        System.out.println(  queue.take());
        System.out.println(  queue.take());
        System.out.println(  queue.take());
        //一直等待 死掉了
        System.out.println(  queue.take());

    }


}

//超时等待
package bq;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @Author 癔症
 * @Date 2020/8/27 15:45
 * @Version 1.0
 */
public class Test {
    public static void main(String[] args) throws InterruptedException {
       Test4();
    }



    public static void Test4() throws InterruptedException {
        ArrayBlockingQueue queue = new ArrayBlockingQueue<>(3);
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        //超时退出
       // queue.offer("d", 2,TimeUnit.SECONDS);
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        System.out.println(queue.poll());
        //超过两秒就退出
       // queue.poll( 2,TimeUnit.SECONDS);
    }

}

同步队列

synchronousQueue
它没有容量,进去一个元素,必须等待取出来之后,才能再放元素.

package bq;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/**
 * @Author 癔症
 * @Date 2020/8/27 16:25
 * @Version 1.0
 */
//同步队列
     //put一个元素,必须先toke取出,否则put不进去
public class synchronousQueueTest {
    public static void main(String[] args) {
        //同步队列
        BlockingQueue<String> synchronousQueue = new SynchronousQueue<>();

          new   Thread(()->{
             try {
                 synchronousQueue.put("1");
                 System.out.println(Thread.currentThread().getName()+"p1");
                 TimeUnit.SECONDS.sleep(3);
                 synchronousQueue.put("2");
                 System.out.println(Thread.currentThread().getName()+"p2");
                 TimeUnit.SECONDS.sleep(3);
                 synchronousQueue.put("3");
                 System.out.println(Thread.currentThread().getName()+"p3");
                 TimeUnit.SECONDS.sleep(3);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         },"T1").start();
        new  Thread(()->{
            try {

                synchronousQueue.take();
                System.out.println(Thread.currentThread().getName()+"------put1");
                TimeUnit.SECONDS.sleep(3);
                synchronousQueue.take();
                System.out.println(Thread.currentThread().getName()+"------put2");
                TimeUnit.SECONDS.sleep(3);
                synchronousQueue.take();
                System.out.println(Thread.currentThread().getName()+"------put3");
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();


    }


}

线程池

线程池:三大方法、7大参数、4种拒绝策略

好处:

1、降低资源的消耗

2、提高响应的速度

3、方便管理

三大方法

package pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author 癔症
 * @Date 2020/8/27 17:04
 * @Version 1.0
 */
//Executors  工具类 、3大方法

public class Demo1 {
    public static void main(String[] args) {
        //ExecutorService threadpool = Executors.newSingleThreadExecutor();//单个线程
       // ExecutorService threadpool2 =  Executors.newFixedThreadPool(5);//创建一个固定大小的线程池
        ExecutorService threadpool3 =  Executors.newCachedThreadPool();//创建一个缓存线程池,遇强则强,遇弱则弱

       /* for (int i = 0; i <10 ; i++) {
            //使用了线程池之后要使用线程池来创建线程
             threadpool.execute(()->{
                 System.out.println(Thread.currentThread().getName()+"单线程线程池");
             });
        }
        try {
        }catch (Exception e){
        }finally {
            //线程池使用完,线程结束,关闭线程池
            threadpool.shutdownNow();
        }*/

        for (int i = 0; i <10 ; i++) {
            //使用了线程池之后要使用线程池来创建线程
            threadpool3.execute(()->{
                System.out.println(Thread.currentThread().getName()+"固定大小线程池");

            });
        }
        try {
        }catch (Exception e){
        }finally {
            //线程池使用完,线程结束,关闭线程池
            threadpool3.shutdownNow();
        }

    }



}

七大参数

这里我们通过源码来进行分析

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }


 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }


它们都是通过ThreadPoolExecutor来实现的
    
    
 public ThreadPoolExecutor(int corePoolSize,//核心线程大小
                              int maximumPoolSize,  //最大核心线程池大小
                              long keepAliveTime,  //超时了没有人调用就会释放
                              TimeUnit unit, //超时单位
                              BlockingQueue<Runnable> workQueue, //阻塞队列
                              ThreadFactory threadFactory,  //创建线程,一般不动
                              RejectedExecutionHandler handler  ) { //拒绝策略
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

四种拒绝策略

AbortPolicy就是抛出异常

CallerRunsPolicy就是 那个线程来的,去哪里 就比方main线程

DiscardOldestPolicy就是 队列满了,会尝试和最早的竞争,也不会抛出异常

DiscardPolicy就是 不会抛出异常,队列满了就停止了

我们去自定义一个线程来使用

package pool;

import java.util.concurrent.*;

/**
 * @Author 癔症
 * @Date 2020/8/27 17:04
 * @Version 1.0
 */
//Executors  工具类 、3大方法

public class Demo1 {
    public static void main(String[] args) {
        //自定义线程池!   ThreadPoolExecutor  最常用的线程池
          ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()); //如果队列满了,还有人进来,不处理,并抛出异常

       /* for (int i = 0; i <10 ; i++) {
            //使用了线程池之后要使用线程池来创建线程
             threadpool.execute(()->{
                 System.out.println(Thread.currentThread().getName()+"单线程线程池");
             });
        }
        try {
        }catch (Exception e){
        }finally {
            //线程池使用完,线程结束,关闭线程池
            threadpool.shutdownNow();
        }*/

        for (int i = 0; i<6 ; i++) {
            //使用了线程池之后要使用线程池来创建线程
            poolExecutor.execute(()->{
                System.out.println(Thread.currentThread().getName()+"自定义线程");

            });
        }
        try {
            //最大承载:阻塞队列加最大线程数   Deque+max  超出此范围   就会走拒绝策略
        }catch (Exception e){
        }finally {
            //线程池使用完,线程结束,关闭线程池
            poolExecutor.shutdownNow();
        }

    }



}

池的最大的大小如何去设置!

查询CPU最大核数

Cpu密集型,几核,就是几,可以保持CPU的效率最高

IO密集型 >判断你程序种十分耗IO的线程

Runtime.getRuntime().availableProcessors();

volatile

volatile是java虚拟机提供轻量级的同步机制

1、保证可见性

package ACID;

import java.util.concurrent.TimeUnit;

/**
 * @Author 癔症
 * @Date 2020/8/30 11:03
 * @Version 1.0
 */
// 工作内存感知不到主内存发生了变化,所以程序才不会结束
public class Vdemo02 {
    private   static int  num=0;
    public static void main(String[] args) {

         new  Thread(()->{
             while (num==0){

             }
         }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);
    }

}

深入浅出JUC并发编程
不加volatile会出现死循环,因为线程感知不到外边值的一个变化,加了volatile会保证一个可见性

package ACID;

import java.util.concurrent.TimeUnit;

/**
 * @Author 癔症
 * @Date 2020/8/30 11:03
 * @Version 1.0
 */
// 工作内存感知不到主内存的变化,所以程序才不会结束
public class Vdemo02 {
    //加上volatile,工作内存可以感知到主内存的变化,保证一致性
    private  volatile static int  num=0;

    public   static  void main(String[] args) {

         new  Thread(()->{//对主内存的变化是不知道的
             while (num==0){

             }
         }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);
    }

}

这里的可见性采用的是一个嗅觉机制和MESI机制.

总线风暴

不断的总线嗅探机制会出现问题
由于volatile的mesi缓存一致性协议需要不断的从主内存嗅探和cas不断循环无效交互导致总线带宽达到峰值

解决方案: 部分volatile和cas使用synchronize

2、不保证原子性

原子性:不可分割,要么同时成功,要么同时失败

线程A在执行任务的时候,不能被打扰的,也不能被分割。

package ACID;

/**
 * @Author 癔症
 * @Date 2020/8/30 19:35
 * @Version 1.0
 *
 */
//不保证原子性
public class VDemo03 {
       public   static   int  num;
       public  static void  add(){
           num++;
       };
    public static void main(String[] args) {
        //num应该是20000,但是它可能输出的不是两万,为什么?
        for (int i = 1; i <=20;i++) {
            new Thread(()->{
                for (int j = 0; j <1000 ; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){// main  gc
            Thread.yield();//暂停线程
        }
        System.out.println(Thread.currentThread().getName()+"------------"+num);
    }
}

原子类

Atomic就是原子类

加上synchronized就可以保证一个原子性,因为synchronized默认是支持原子性的

但是加上volatile不会保证原子性

使用原子类 解决原子性问题,我们根本你不需要使用volatile和synchronized

package ACID;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author 癔症
 * @Date 2020/8/30 19:35
 * @Version 1.0
 *
 */
//不保证原子性
public class VDemo03 {
        //不保证原子性
        //我们可以使用原子类
       public   static AtomicInteger atomicInteger =new AtomicInteger();
       public    static void  add(){
           //不是一个原子性操作
           //num++;
             atomicInteger.getAndIncrement();//使用原子类执行+1的操作
       };
    public static void main(String[] args) {
        //num应该是20000,但是它可能输出的不是两万,为什么?
        for (int i = 1; i <=20;i++) {
            new Thread(()->{
                for (int j = 0; j <1000 ; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){// main  gc
            Thread.yield();//暂停线程
        }
        System.out.println(Thread.currentThread().getName()+"------------"+atomicInteger);
    }
}

原子类的底层直接和操作系统挂钩,在内存中修改值!它底层是一个Unsafe类,Unsafe底层大量调用了native方法,说明调用的是其他语言的方法.(很深层).

3、禁止指令重排

代码在编译的时候,指令会进行一个重新排序,这个就是指令重排

加了volatile关键字会产生内存屏障 作用:

1、保证特定的操作的执行顺序!

2、可以保证某些变量的内存可见性(利用这些特性volatile实现了可见性)

读写的时候,加上volatile会在上下产生一个内存屏障,去禁止上下指令顺序交换
深入浅出JUC并发编程

总结:volatile保证可见性,不保证原子性,由于内存屏障,可以保证避免指令重排的现象产生

CAS

CAS(比较并交换),在并发不是特别大的情况下,锁竞争不激烈,你要去修改这个东西,你要先查,查完之后,再修改,修改完,准备写进去之前,它会再查一次,比较之前的结果有没有区别,如果有区别说明这个修改是不安全的.如果要是没有区别,说明这个修改是安全的,这个时候它就可以安全的去修改,而不是直接加锁的那种形式,在低并发的情况性能会好一点!
缺点:

1、由于底层是自旋锁,循环会耗时

2、一次只能保证一个共享变量的原子性

3、高并发情况下大量使用它会出现ABA问题

ABA问题

package cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author 癔症
 * @Date 2020/8/31 19:04
 * @Version 1.0
 */
public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //如果我们期望的值达到了,那么就更新,否则,就不更新,CAS是 CPU的并发原语
        
        System.out.println(atomicInteger.compareAndSet(2020,2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2021,2020));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2020,6666));
        System.out.println(atomicInteger.get());
    }

}

之前读和再过读中间可能被第三人修改过,但是又给改了回来.

原子引用解决ABA

AtomicStampedReference增加版本号,如果有人来修改,则增加版本号.

package cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @Author 癔症
 * @Date 2020/8/31 19:04
 * @Version 1.0
 */
public class CASDemo {
   static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
    public static void main(String[] args) {


          new Thread(()->{
               int  stamp=atomicStampedReference.getStamp();//获得这个版本号
              System.out.println("a----->"+stamp);

              try {
                  TimeUnit.SECONDS.sleep(1);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              //compareAndSet    比较并交换
              System.out.println(atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
              System.out.println("aa----->"+atomicStampedReference.getStamp());
              System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
              System.out.println("aaa----->"+atomicStampedReference.getStamp());
          },"A").start();
        //底层是使用了乐观锁原理
          new  Thread(()->{
               int  stamp= atomicStampedReference.getStamp();
              System.out.println("b----->"+stamp);
              try {
                  TimeUnit.SECONDS.sleep(2);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(atomicStampedReference.compareAndSet(1, 6, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
              System.out.println("bb----->"+atomicStampedReference.getStamp());
          },"B").start();
    }


}

思想跟乐观锁几乎一样

可重入锁

可重入锁(递归锁):拿到了外面的锁之后,就可以拿到里面的锁,自动获取

自旋锁

CAS底层就是通过自旋锁来实现的.

在Java中,自旋锁是指尝试获取锁的线程不会立即阻塞,而是采用循环的方式去尝试获取锁,这样的好处是减少线程上下文切换的消耗,缺点是循环会消耗CPU

总结:谢谢大家的支持,如果文章中有什么错误或者那块理解的不是很到位,请各位及时补充一下!不喜勿喷,互相帮助!共同进步!

深入浅出JUC并发编程

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。