• 学习笔记-JUC基础

    JUC

    • java.util.concurrent

    线程

    • 程序

      • 进程
        • 线程
          • Thread.State
            • NEW:新建
            • TUNNABLE:准备就绪
            • BLOCKED:阻塞
            • WAITING:不见不散
            • TIMED_WAITING:过时不候
            • TERMINATED:终结
          • wait
            • Object方法
            • 占用锁，会释放锁
          • sleep
            • Thread方法
            • 不占用锁，不会释放锁
          • 串行
          • 并行
          • 管程
            • 同步机制，保证同一时间只有一个线程访问
          • 用户线程
            • 自定义线程
            • 主线程结束，用户线程还未结束，还可以继续运行
          • 守护线程
            • 比如垃圾回收
            • 主线程结束，守护线程不可以继续运行

    • 守护线程

    Thread aa = new Thread(()->{
    System.out.println(Thread.currentThread().getName()+"::"+Thread.currentThread().isDaemon);
    while(true){
        
    }
    
},"aa");
// 设置守护线程
aa.setDaemon(true);
aa.start();
System.out.println(Thread.currentThread().getName() + "over");

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    lock

    • lock

      • 接口，手动上锁解锁

    • sunchronized

      • 关键字，自动上锁解锁

    • 多线程编程步骤

      • 1、创建资源类，属性和方法
      • 2、在资源类中操作方法
        • 判断
        • 干活
        • 通知
      • 3、创建多个线程，调用资源类方法

    sunchronized

    
// 资源类
public class Ticket{
    private int num = 30;
    // 操作方法
    public synchronized void sale(){
        // 判断是否有票
        if(num>0){
            System.out.println(Thread.currentThread().getName() + "卖出："+(numbr--) + " 剩下：" + num);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    public class SaleTicket{
    // 创建多个线程，调用资源类方法
    pubic static void main(String[] args){
        // 创建Ticket
        Ticket ticket = new Ticket();
        // 创建三个线程
        new Thread(()->{
            for(int i=0;i<40;i++){
                ticket.sale();
            }
        },"AA").start();
        new Thread(()->{
            for(int i=0;i<40;i++){
                ticket.sale();
            }
        },"BB").start();
        new Thread(()->{
            for(int i=0;i<40;i++){
                ticket.sale();
            }
        },"CC").start();
    }
    
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    lock

    • 可重入锁
    
// 资源类
public class Ticket{
    private int num = 30;
    // 创建可重入锁
    private final ReentrantLock lock = new ReentrantLock();
    // 操作方法
    public void sale(){
        // 上锁
        lock.lock();
        try{
            // 判断是否有票
            if(num>0){
                System.out.println(Thread.currentThread().getName() + "卖出："+(numbr--) + " 剩下：" + num);
            }
        }finally{
            // 解锁
            lock.unlock();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    线程间通讯

    synchronized

    // 资源类
public class Share{
    private int num = 0;
    // +1
    public synchronized void incr(){
        // 判断 干活 通知
        while(num!=0){
            // 不等于0 等待
            this.wait();// 在哪里睡，就在哪里醒，所以需要不停判断num值
        }
        num++;
        System.out.println(Thread.currentThread().getName() + ":: " + num);
        // 通知其他线程,可能虚假唤醒
        this.notifyAll();
    }
    // -1
    public synchronized void decr(){
       // 判断 干活 通知
        while(num!=1){
            // 不等于1 等待
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + ":: " + num);
        // 通知其他线程,可能虚假唤醒
        this.notifyAll();
        
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    public class Demo{
    // 创建多个线程调用
    public static void main(String[] args){
        Share share = new Share();
        // 创建线程
        new Thread(()->{
            for(int i=0;i<10;i++){
                share.incr();
            }
        },"AA").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                share.decr();
            }
        },"BB").start();
    }
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    lock

    // 资源类
public class Share{
    private int num = 0;
    // 创建lock
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    // +1
    public synchronized void incr(){
        // 上锁
        lock.lock();
        try{
            // 判断 干活 通知
            while(num!=0){
                // 不等于0 等待
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + ":: " + num);
            // 通知其他线程
            condition.signallAll();
        }finally{
            lock.unlock();
        }
      
    }
    // -1
    public synchronized void decr(){
        // 上锁
        lock.lock();
        try{
            // 判断 干活 通知
            while(num!=0){
                // 不等于0 等待
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + ":: " + num);
            // 通知其他线程
            condition.signallAll();
        }finally{
            lock.unlock();
        }
        
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    定制化通讯

    public class ShareResource{
    // 创建标志位 1-AA 2-BB 3-CC
    private int flag = 1;
    // 创建lock
    private Lock lock = new ReentrantLock();
    private Condition c1 = lock.newCondition();
    private Condition c2 = lock.newCondition();
    private Condition c3 = lock.newCondition();
    
    // 打印5次
    public void print5(int loop){
        // 上锁
        lock.lock();
        try{
            // 判断 干活 通知
            while(flag!=1){
                // 不等于0 等待
                c1.await();
            }
            for(int i=1;i<=5;i++){
                System.out.println(Thread.currentThread().getName() + ":: " + i + " 轮数 ："+loop);
            }
            // 通知其他线程
            flag = 2; // 修改标志位
            c2.signal();
        }finally{
            lock.unlock();
        }
    }
    // 打印10次
    public void print10(int loop){
        // 上锁
        lock.lock();
        try{
            // 判断 干活 通知
            while(flag!=2){
                // 不等于0 等待
                c2.await();
            }
            for(int i=1;i<=10;i++){
                System.out.println(Thread.currentThread().getName() + ":: " + i + " 轮数 ："+loop);
            }
            // 通知其他线程
            flag = 3; // 修改标志位
            c3.signal();
        }finally{
            lock.unlock();
        }
    }
    
    // 打印15次
    public void print10(int loop){
        // 上锁
        lock.lock();
        try{
            // 判断 干活 通知
            while(flag!=3){
                // 不等于0 等待
                c3.await();
            }
            for(int i=1;i<=15;i++){
                System.out.println(Thread.currentThread().getName() + ":: " + i + " 轮数 ："+loop);
            }
            // 通知其他线程
            flag = 1; // 修改标志位
            c1.signal();
        }finally{
            lock.unlock();
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    ShareResource share = new ShareResource();

new Thread(()->{
   for(int i=0;i<10;i++){
       share.print5(i);
   } 
},"AA").start();
new Thread(()->{
   for(int i=0;i<10;i++){
       share.print10(i);
   } 
},"BB").start();
new Thread(()->{
   for(int i=0;i<10;i++){
       share.print15(i);
   } 
},"CC").start();


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    集合线程安全

    • 不安全演示
    List<String> list = new ArrayList<>();
for(int i=0;i<10;i++){
    new Thread(()->{
        // add()不存在synchronized，线程不安全
        list.add(UUID.randomUUID().toString().substring(0,8));
        // 获取内容
        System.out.println(list);// 抛出异常ConcurrentModificationException
    },String.valueOf(i)).start();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    Vector

    List<String> list = new Vector<>();
for(int i=0;i<10;i++){
    new Thread(()->{
        // add()存在synchronized,线程安全
        list.add(UUID.randomUUID().toString().substring(0,8));
        // 获取内容
        System.out.println(list);// 抛出异常ConcurrentModificationException
    },String.valueOf(i)).start();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    Collections

    • Collections
      • sychronizedList()
    List<String> list = Collections.sychronizedList(new ArrayList<>());
for(int i=0;i<10;i++){
    new Thread(()->{
        // 线程安全
        list.add(UUID.randomUUID().toString().substring(0,8));
        // 获取内容
        System.out.println(list);// 抛出异常ConcurrentModificationException
    },String.valueOf(i)).start();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    CopyOnWriteArrayList

    • 线程安全类
      • CopyOnWriteArrayList
      • CopyOnWriteArraySet
      • ConcurrentHashMap
    List<String> list = new CopyOnWriteArrayList<>();
for(int i=0;i<10;i++){
    new Thread(()->{
        // 线程安全
        list.add(UUID.randomUUID().toString().substring(0,8));
        // 获取内容
        System.out.println(list);// 抛出异常ConcurrentModificationException
    },String.valueOf(i)).start();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    多线程锁

    • 静态方法
      • 当前类
    • 普通方法
      • 当前实例对象
    • 同步代码块
      • 配置的对象
    public class Phone{
    public sychronized void sendSMS(){
        TimeUnit.SECHOUDS.sleep(4);
        System.out.println("sendSMS");
    }
    
    public static synchronized void sendEmail(){
        System.out.println("sendEmail");
    }
    
    public void getHello(){
        System.out.println("getHello");
    }
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    Phone phone = new Phone();

new Thread(()->{
    phone.sendSMS();
},"AA").start();
new Thread(()->{
    phone.sendEmail();
},"BB").start();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 公平锁&非公平锁
    • 可重入锁
      • synchronized(隐式)
      • lock（显式）
    Object o = new Object();
new Thread(()->{
    synchronized(o){
        System.out.println(Thread.currentThread().getName()+" 外层");
        synchronized(o){
            System.out.println(Thread.currentThread().getName()+" 中层");
            synchronized(o){
                System.out.println(Thread.currentThread().getName()+" 内层");
            }
        }
    }
},"t1").star();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    Lock o = new ReentrantLock();
new Thread(()->{
    try{
        lock.lock();
        System.out.println(Thread.currentThread().getName()+" 外层");
            try{
                lock.lock();
                System.out.println(Thread.currentThread().getName()+" 中层");
                    try{
                        lock.lock();
                        System.out.println(Thread.currentThread().getName()+" 内层");
                    }finally{
                        lock.unlock();
                    }
            }finally{
                lock.unlock();
            }
    }finally{
        lock.unlock();
    }
   
},"t1").star();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 死锁
      • jps -l
        • 查看进程
      • jstack xxx
        • 查看进程详情
    public class DeadLock{
    static Object a = new Object();
    static Object b = new Object();
    
    public static main(String[] args){
        new Thread(()->{
            sychronized(a){
                System.out.println(Thread.currentThread().getName()+" 持有a，想要b");
                TimeUtil.SECONDS.sleep(1);
                sychronized(b){
                    System.out.println(Thread.currentThread().getName()+" 获取b");
                }
            }
        },"AA").start();
        new Thread(()->{
            sychronized(b){
                System.out.println(Thread.currentThread().getName()+" 持有b，想要a");
                TimeUtil.SECONDS.sleep(1);
                sychronized(a){
                    System.out.println(Thread.currentThread().getName()+" 获取a");
                }
            }
        },"BB").start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    callable

    • 创建线程方式
      • 继承Thread
      • 实现Runnable接口
        • 没有返回值
        • 没有异常抛出
        • run()
      • 实现Callable接口
        • 有返回值
        • 有异常
        • call()
      • 线程池
    public class MyThread1 implements Runnable{
    public void run(){
        
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    public class MyThread2 implements Callable{
    public Integer call() throws Exception{
        return 200;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    // Runnable
new Thread(new MyThreaad1(),"AA").start();
// Callable
FutureTask<Integer> futureTask1 = mew FutureTask<>(new MyThread2());
FutureTask<Integer> futureTask2 = mew FutureTask<>(()->{
    System.out.println(Thread.currentThread().getName()+" come in callable");
    return 1024;
});
new Thread(futureTask2,"lucy").start()
while(!futureTask2.isDone()){
    System.out.println("wait");
}
System.out.println(futureTask2.get());

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    JUC辅助类

    CountDownLatch

    public class CountDownLatchDemo{
    CountDownLatch countDownLatch = new CountDownLatch(6);
    public static void main(String[] args){
        // 6 个
        for(int i=0;i<=6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                // 计数-1
                countDownLatch.countDown();
            },String.valueOf(i)).start();
        }
        // 计数为0后放行
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    CyclicBarrier

    public class CyclicBarrierDemo{
    public static final int NUMBER = 7;
    
    public static void main(String[] args){
        // 7 个
        CyclicBarrier cyclierBarrier = new CyclierBarrier(NUMBER,()->{
            System.out.println("已经"+NUMBER+"次了");
        });
        for(int i=1;i<=7;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                // 计数+1
                cyclierBarrier.await();
            },String.valueOf(i)).start();
        }
       
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    Semaphore

    public class SemaphoreDemo{
    
    public static void main(String[] args){
        // 3 个许可数量
        Semaphore cyclierBarrier = new Semaphore(3);
        for(int i=1;i<=6;i++){
            new Thread(()->{
                try{
                     // 抢占
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到");
                    // 设置随机时间
                    TimeUtil.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName()+"离开");
                }catch(Exception e){
                    
                }finally{
                    // 释放
                    semaphore.release();
                }
               
            },String.valueOf(i)).start();
        }
       
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    读写锁

    • 悲观锁

      • 当前操作人上锁

    • 乐观锁

      • 根据版本号进行判断

    • 表锁

    • 行锁

    • 读锁

      • 共享锁
      • 会发生死锁

    • 写锁

      • 独占锁
      • 会发生死锁

    ReadWriteLock

    // 资源类
public class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();
    
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    
    // 放数据
    public void put(String key,Object value){
        // 添加写锁
        rwLock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+" 正在操作"+key);
            TimeUtil.MICROSECONDS.sleep(300);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+" 写完"+key);
        }finally{
            // 释放
            rwLock.writeLock().unlock();
        }
        
    }
    
    public void get(String key){
        // 添加写锁
        rwLock.readLock().lock();
        Object result = null;
        try{
            System.out.println(Thread.currentThread().getName()+" 正在读取"+key);
            TimeUtil.MICROSECONDS.sleep(300);
            map.put(key,value);
            result = map.get(key);
            System.out.println(Thread.currentThread().getName()+" 取完"+key);
        }finally{
            // 释放
            rwLock.readLock().unlock();
        }
        
        return result;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    MyCache myCache = new MyCache();
for(int i=1;i<=5;i++){
    final int num = i;
    new Thread(()->{
        myCache.put(num+"",num+"");
    },String.valueOf(i)).start();
}
for(int i=1;i<=5;i++){
    final int num = i;
    new Thread(()->{
        myCache.get(num+"");
    },String.valueOf(i)).start();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    读写锁降级
    ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();// 读锁
ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();// 写锁

// 锁降级
// 写锁可降级为读锁
// 读锁不能升级为写锁
// 1 获取写锁
writeLock.lock();
System.out.println("获取写锁");
// 2 获取读锁
readLock.lock();
System.out.println("获取读锁");
writeLock.unlock();
readLock.unlock();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    阻塞队列

    • BlockingQueue
      • ArrayBlockingQueue
      • LinkedBlockingQueue
      • DelayQueue
      • PriorityBlockingQueue
      • SynchronousQueue
      • LinkedTransferBlockingQueue
      • LinkedBlockingDeque
    BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
// 1
blockingQueue.add("a");// 返回true
blockingQueue.add("b");// 返回true
blockingQueue.add("c");// 返回true
blockingQueue.element();// a

// blockingQueue.add("w");// 抛出异常
blockingQueue.remove(); // a
blockingQueue.remove(); // b
blockingQueue.remove(); // c
// blockingQueue.remove(); // 抛出异常

// 2
blockingQueue.offer("a");// 返回true
blockingQueue.offer("b");// 返回true
blockingQueue.offer("c");// 返回true
blockingQueue.offer("w");// 返回false
blockingQueue.poll(); // a
blockingQueue.poll(); // b
blockingQueue.poll(); // c
blockingQueue.poll(); // null

// 3
blockingQueue.put("a"); 
blockingQueue.put("b"); 
blockingQueue.put("c"); 
blockingQueue.put("w");// 阻塞
blockingQueue.take(); // a
blockingQueue.take(); // b
blockingQueue.take(); // c
blockingQueue.take(); // 阻塞

// 4
blockingQueue.offer("a"); 
blockingQueue.offer("b"); 
blockingQueue.offer("c"); 
blockingQueue.offer("w",3L,TimeUnit.SECONDS);// 设置阻塞超时时间



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    线程池

    • 一池N线程
    • 一池一线程
    • 一池可扩容线程池
    
public class ThreadPoolDemo{
    public static void main(String[] args){
        // 一池多线程
        ExecutrService threadPool1 = Executors.newFixedThreadPool(5);
        try{
            // 10个任务
            for(int i=0;i<=10;i++){
                threadPool1.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        }finally{
            // 关闭
            threadPool1.shutdown();
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    
public class ThreadPoolDemo{
    public static void main(String[] args){
        // 一池一线程
        ExecutrService threadPool2 = Executors.newSingleThreadPool();
        try{
            // 10个任务
            for(int i=0;i<=10;i++){
                threadPool2.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        }finally{
            // 关闭
            threadPool2.shutdown();
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    
public class ThreadPoolDemo{
    public static void main(String[] args){
        // 一池可扩容线程池
        ExecutrService threadPool3 = Executors.newCachedThreadPool();
        try{
            // 10个任务
            for(int i=0;i<=20;i++){
                threadPool3.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        }finally{
            // 关闭
            threadPool3.shutdown();
        }
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    线程池7个参数

    • int corePoolSize
      • 核心（常用）线程数量
    • int maximumPoolSize
      • 最大线程数
    • Long keepAliveTime & TimeUnit unit
      • 线程存活时间
    • BlockingQueue workQueue
      • 阻塞队列
    • ThreadFactory threadFactory
      • 线程工厂
    • RejectedExecutionHandler handler
      • 拒绝策略
        • AbortPolicy策略（默认）,抛出异常
        • CallerRunsPolicy,退回调用者
        • DiscardOldestPolicy,抛弃队列中等待最久的任务
        • DiscardPolicy,丢弃，不抛异常

    自定义线程池

    public class ThreadPoolDemo{
    public static void main(String[] args){
        ExecutorService threadPool = new ThreadPoolExecutor(2,5,
            2L,TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(3),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());
    }
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    Fork&Join框架

    public class MyTask extends RecursiveTask<Integer>{
    // 拆分 插值不超过10,计算10以内的计算
    private static final Integer VALUE = 10; 
    private int begin;
    private int end;
    private int result;
    
    public MyTask(int begin,int end){
        this.begin = begin;
        this.end = end;
    }
    
    protected Integer compute(){
        // 判断 
        if((end-begin)<=VALUE){
            for(int i=begin;i<=end;i++){
                result = result+i;
            }
        }else{
            // 中间值
            int middle = (begin+end)/2;
            // 拆左边
            MyTask task1 = new MyTask(begin,middle);
            // 拆右边
            MyTask task2 = new MyTask(middle+1,end);
            // 拆分
            task1.fork();
            task2.fork();
            // 合并
            result = task1.join()+task2.join();
        }
        return result;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    public static void main(String[] args){
    MyTask task = new MyTask(0,100);
    // 分支合并池
    ForkJoinPool forkJoinPool = new ForkJoinPool();
    ForkJoinPoolTask<Integer> forkJoinTask = forkJoinPool.submit(myTask);
    // 合并结果
    Integer result = forkJoinTask.get();
    // 关闭池
    forkJoinPool.shutdown();
    
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    异步回调

    • CompletableFuture
    // 异步调用 没有返回值
CompletableFuture<Void> c1 = CompletableFuture.runAsync(()->{
    System.out.println(Thread.currentThread().getName());
});
c1.get();

// 异步调用 有返回值
CompletableFuture<Integer> c2 = CompletableFuture.supplyAsync(()->{
    System.out.println(Thread.currentThread().getName());
    int a = i/0;// 模拟异常
    return 1024;
});

c2.whenComplete((t,u)->{
    System.out.println(t); // 方法的返回值
    System.out.println(u); // 返回异常
}.get();



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
  • 相关阅读:
    金融数字化是什么？如何进行金融数字化转型？
    截图小技巧yyds
    redis高可用（主从复制，哨兵，集群）
    3ds MAX 2024版资源包下载分享 3ds Max三维建模软件资源包下载安装
    C和指针 第11章 动态内存分配 11.2 malloc和free
    计算机毕业设计Java创意产业园区管理(源码+系统+mysql数据库+lw文档)
    前后端接口调用传参方式总结
    windows10 使用WSL2安装原生docker
    每天5分钟玩转Kubernetes | Dashboard典型使用场景
    单商户商城系统功能拆解20—售后订单
  • 原文地址：https://blog.csdn.net/weixin0605/article/details/128070916