JUC学习笔记（二）

最新推荐文章于 2023-06-14 16:55:02 发布

我敲代码像把梭

最新推荐文章于 2023-06-14 16:55:02 发布

阅读量315

点赞数

本文链接：https://blog.csdn.net/qq_35402580/article/details/105384236

版权

volatile关键字

JMM（Java Memory Model | Java内存模型）

JMM是一种抽象的概念，不是真实存在的，它描述了一种规范，通过这组规范定义了程序中的访问方式

JMM同步规定

程序加锁前，必须读取主内存中的最新值到工作内存
程序解锁前，必须将工作内存中的最新值写入到主内存
加锁解锁是同一把锁

原理

由于 JVM 运行程序的实体是线程，而每个线程创建时 JVM 都会为其创建一个工作内存，工作内存是每个线程的私有数据区域，而 Java 内存模型中规定所有变量的储存在主内存，主内存是共享内存区域，所有的线程都可以访问，但线程对变量的操作（读取赋值等）必须都工作内存进行，操作后，再写回主内存

工作流程

首先要将变量从主内存拷贝的自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，工作内存中存储着主内存中的变量副本拷贝，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成。

内存模型图

在这里插入图片描述

volatile特点

可见性

/**
* 可见性代码实例
* 1.data对象中a的值为0，主线程中以while的方式设置当a为0时的死循环
* 2.开启一个新线程，将a的值加1
* 3.主线程检测到a的值不为0，结束死循环
* 由此证明：volatile可见性的特点
*/
public class VolatileDemo {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " coming...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            data.addOne();
            System.out.println(Thread.currentThread().getName() + " updated...");
        }).start();

        while (data.a == 0) {
            // looping
        }
        System.out.println(Thread.currentThread().getName() + " job is done...");
    }
}

class Data {
    // int a = 0;
    volatile int a = 0;
    void addOne() {
        this.a += 1;
    }
}

禁止指令重排

指令重排
计算机在执行程序时，为了提高性能，编译器个处理器常常会对指令做重排，一般分为以下 3 种：
1. 编译器优化的重排
2. 指令并行的重排
3. 内存系统的重排

在单线程环境中，可确保代程序执行的结果和代码执行的结果一致
多线程环境下，线程交替执行，处理器在指令重排时，需要考虑指令之间的依赖性，两个线程中使用的变量能否保证用的变量能否一致性是无法确定的，结果无法预测

/**
 * 指令重排代码实例
 * A线程执行方法一,但是无法保证先a=1,后执行flag = true执行在后
 * 多次执行后，发现执行结果不同
*/
public class ReSortSeqDemo {
    int a = 0;
    boolean flag = false;
    
    public void method01() {
        a = 1;           // flag = true;
        flag = true;     // a = 1;
    }
    public void method02() {
        if (flag) {
            a = a + 1;
            System.out.println("a = " + a);
        }
    }
	public static void main(String[] args){
		
		ReSortSeqDemo d = new OrderExample()
		//A线程执行方法一,但是无法保证先a=1,后执行flag = true执行在后
		new Thread(() -> {
			d.method01();
		},"thread01").start();
		
		//线程 B执行方法二
		new Thread(() -> {
			d.method02();
		},"thread02").start();
	}
}

禁止指令重排
volatile 实现禁止指令重排序的优化，从而避免了多线程环境下程序出现乱序的现象
内存屏障（Memory Barrier）又称内存栅栏，是一个 CPU 指令，他的作用有两个：
1. 保证特定操作的执行顺序
2. 保证某些变量的内存可见性
由于编译器个处理器都能执行指令重排序优化，如果在指令间插入一条 Memory Barrier (Store屏障和Load屏障),则会告诉编译器和 CPU，不管什么指令都不能个这条 Memory Barrier 指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后执行重排序优化。内存屏障另一个作用是强制刷出各种 CPU 缓存数据，因此任何 CPU 上的线程都能读取到这些数据的最新版本。
volatile在单例中的使用

/**
 * 懒汉式单例模式存在线程安全问题
 * 多线程调用getInstance()方法时，多次打印了构造方法中的字符串内容输出
 * 证明懒汉式存在线程安全问题
*/
public class Singleton {
    private static Singleton instance = null;
    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "  construction...");
    }
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.execute(()-> Singleton.getInstance());
        }
        executorService.shutdown();
    }
}

双重锁单例

/**
 * 双重锁单例
 * 1.当该类中未创建对象时，通过sychronized方法加锁再判断是否创建了对象，如果仍然未创建，则创建该对象，当sychronized锁的对象为类时，该类的所有对象执行该静态方法时，都为同步方法
 * 2.如果没有加 volatile 就不一定是线程安全的，原因是指令重排序的存在，加入 volatile 可以禁止指令重排。某一个线程执行到第一次检测，读取到的 instance 不为 null 时，instance 的引用对象可能还没有完成初始化。
*/
public class Singleton {
    private static volatile Singleton instance = null;
    private Singleton() {
        System.out.println(Thread.currentThread().getName() + "  construction...");
    }
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.execute(()-> Singleton.getInstance());
        }
        executorService.shutdown();
    }
}

instance = new Singleton() 可以分为以下三步完成

emory = allocate();  // 1.分配对象空间
instance(memory);     // 2.初始化对象
instance = memory;    // 3.设置instance指向刚分配的内存地址，此时instance != null

步骤 2 和步骤 3 不存在依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种优化是允许的。

发生重排时

memory = allocate();  // 1.分配对象空间
instance = memory;    // 3.设置instance指向刚分配的内存地址，此时instance != null，但对象还没有初始化完成
instance(memory);     // 2.初始化对象

所以不加 volatile 返回的实例不为空，但可能是未初始化的实例

无法保证原子性

/**
 * 多线程在调用test方法时，
 * 
*/
public class VolatileDemo {
    public static void main(String[] args) {
       test();
    }
    // 测试原子性
    private static void test() {
        Data data = new Data();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    data.addOne();
                }
            }).start();
        }
        // 默认有 main 线程和 gc 线程
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(data.a);
    }
}

class Data {
    volatile int a = 0;
    void addOne() {
        this.a += 1;
    }
}

CAS方法

作用

即AtomicInteger中的compareAndSet(a, b)方法，先校验当前对象值是否与a相等，如果相等则将AtomicInteger对象的值加到b，该方法返回的是boolean值，如果加成功返回true，失败返回false

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(666);
        // 校验atomicInteger的值是否为666
        boolean b = atomicInteger.compareAndSet(666, 2019);
        System.out.println(b); // true
        boolean b1 = atomicInteger.compareAndSet(666, 2020);
        System.out.println(b1); // false
        atomicInteger.getAndIncrement();//2019
    }
}

缺点

循环时间长开销很大
如果 CAS 失败，会一直尝试，如果 CAS 长时间一直不成功，可能会给 CPU 带来很大的开销（比如线程数很多，每次比较都是失败，就会一直循环），所以希望是线程数比较小的场景
只能保证一个共享变量的原子操作
对于多个共享变量操作时，循环 CAS 就无法保证操作的原子性
aba问题
当有一个值从 A 改为 B 又改为 A，该数据已经被修改了两次，如果修改次数对业务有影响，那么无法察觉该数据已经被修改过

aba问题的解决

采用时间戳类型的原子引用

public class ABADemo {
    private static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 );
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1 );
        }).start();

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + " 的版本号为：" + stamp);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean b = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp + 1);
            System.out.println(b); // false
            System.out.println(atomicStampedReference.getReference()); // 100
        }).start();
    }
}

加入版本号的使用，调用compareAndSet方法时，要当前的值和当前的版本号，校验成功后，才会替换为输入的值和版本号，并返回false

java 中的锁

公平和非公平锁

公平锁 是指多个线程按照申请的顺序来获取值
非公平锁 是值多个线程获取值的顺序并不是按照申请锁的顺序，在高并发的情况下，可能会有优先级翻转或者饥饿现象

区别：
公平锁在并发环境中，每一个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个就占有锁，否者就会加入到等待队列中，以后会按照 FIFO 的规则获取锁
非公平锁一上来就尝试占有锁，如果失败在进行排队

可重入锁和不可重入锁

可重入锁

指的是同一个线程外层函数获得锁之后，内层仍然能获取到该锁，在同一个线程在外层方法获取锁的时候，在进入内层方法或会自动获取该锁
代码实现：

public class ReentrantLock {
    boolean isLocked = false;
    Thread lockedBy = null;
    int lockedCount = 0;
    public synchronized void lock() throws InterruptedException {
        Thread thread = Thread.currentThread();
        while (isLocked && lockedBy != thread) {
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedBy = thread;
    }
    
    public synchronized void unlock() {
        if (Thread.currentThread() == lockedBy) {
            lockedCount--;
            if (lockedCount == 0) {
                isLocked = false;
                notify();
            }
        }
    }
}
//调用
public class Count {
//    NotReentrantLock lock = new NotReentrantLock();
    ReentrantLock lock = new ReentrantLock();
    public void print() throws InterruptedException{
        lock.lock();
        doAdd();
        lock.unlock();
    }

    private void doAdd() throws InterruptedException {
        lock.lock();
        // do something
        System.out.println("ReentrantLock");
        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        Count count = new Count();
        count.print();
    }
}

发现可以输出 ReentrantLock，我们设计两个线程调用 print() 方法，第一个线程调用 print() 方法获取锁，进入 lock() 方法，由于初始 lockedBy 是 null，所以不会进入 while 而挂起当前线程，而是是增量 lockedCount 并记录 lockBy 为第一个线程。接着第一个线程进入 doAdd() 方法，由于同一进程，所以不会进入 while 而挂起，接着增量 lockedCount，当第二个线程尝试lock，由于 isLocked=true，所以他不会获取该锁，直到第一个线程调用两次 unlock() 将 lockCount 递减为0，才将标记为 isLocked 设置为 false

synchronized

public class SynchronziedDemo {

    private synchronized void print() {
        doAdd();
    }
    private synchronized void doAdd() {
        System.out.println("doAdd...");
    }

    public static void main(String[] args) {
        SynchronziedDemo synchronziedDemo = new SynchronziedDemo();
        synchronziedDemo.print(); // doAdd...
    }
}

ReentrantLock

public class ReentrantLockDemo {
    private Lock lock = new ReentrantLock();

    private void print() {
        lock.lock();
        doAdd();
        lock.unlock();
    }

    private void doAdd() {
        lock.lock();
        lock.lock();
        System.out.println("doAdd...");
        lock.unlock();
        lock.unlock();
    }

    public static void main(String[] args) {
        ReentrantLockDemo reentrantLockDemo = new ReentrantLockDemo();
        reentrantLockDemo.print();
    }
}

不可重入锁

所谓不可重入锁，即若当前线程执行某个方法已经获取了该锁，那么在方法中尝试再次获取锁时，就会获取不到被阻塞
代码实现：

public class NotReentrantLock {
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException {
        while (isLocked) {
            wait();
        }
        isLocked = true;
    }
    public synchronized void unlock() {
        isLocked = false;
        notify();
    }
}

public class Count {
    NotReentrantLock lock = new NotReentrantLock();
    public void print() throws InterruptedException{
        lock.lock();
        doAdd();
        lock.unlock();
    }

    private void doAdd() throws InterruptedException {
        lock.lock();
        // do something
        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        Count count = new Count();
        count.print();
    }
}

当前线程执行print()方法首先获取lock，接下来执行doAdd()方法就无法执行doAdd()中的逻辑，必须先释放锁。这个例子很好的说明了不可重入锁

自旋锁

是指定尝试获取锁的线程不会立即堵塞，而是**采用循环的方式去尝试获取锁，**这样的好处是减少线程上下文切换的消耗，缺点就是循环会消耗 CPU
代码实现

public class SpinLock {
    private AtomicReference<Thread> atomicReference = new AtomicReference<>();
    private void lock () {
        System.out.println(Thread.currentThread() + " coming...");
        while (!atomicReference.compareAndSet(null, Thread.currentThread())) {
            // loop
        }
    }

    private void unlock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(thread + " unlock...");
    }

    public static void main(String[] args) throws InterruptedException {
        SpinLock spinLock = new SpinLock();
        new Thread(() -> {
            spinLock.lock();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hahaha");
            spinLock.unlock();

        }).start();

        Thread.sleep(1);

        new Thread(() -> {
            spinLock.lock();
            System.out.println("hehehe");
            spinLock.unlock();
        }).start();
    }
}

输出

Thread[Thread-0,5,main] coming...
Thread[Thread-1,5,main] coming...
hahaha
Thread[Thread-0,5,main] unlock...
hehehe
Thread[Thread-1,5,main] unlock...

当锁被其他线程获取时，就循环等待

独占锁（写锁）/共享锁（读锁）

独占锁：指该锁一次只能被一个线程持有
共享锁：该锁可以被多个线程持有

对于 ReentrantLock 和 synchronized 都是独占锁；对与 ReentrantReadWriteLock 其读锁是共享锁而写锁是独占锁。读锁的共享可保证并发读是非常高效的，读写、写读和写写的过程是互斥的。

代码实现

public class MyCache {

    private volatile Map<String, Object> map = new HashMap<>();

    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    WriteLock writeLock = lock.writeLock();
    ReadLock readLock = lock.readLock();

    public void put(String key, Object value) {
        try {
            writeLock.lock();
            System.out.println(Thread.currentThread().getName() + " 正在写入...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + " 写入完成，写入结果是 " + value);
        } finally {
            writeLock.unlock();
        }
    }

    public void get(String key) {
        try {
            readLock.lock();
            System.out.println(Thread.currentThread().getName() + " 正在读...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Object res = map.get(key);
            System.out.println(Thread.currentThread().getName() + " 读取完成，读取结果是 " + res);
        } finally {
            readLock.unlock();
        }
    }
}

测试

public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache cache = new MyCache();

        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() -> {
                cache.put(temp + "", temp + "");
            }).start();
        }

        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() -> {
                cache.get(temp + "");
            }).start();
        }
    }
}

输出结果

Thread-0 正在写入...
Thread-0 写入完成，写入结果是 0
Thread-1 正在写入...
Thread-1 写入完成，写入结果是 1
Thread-2 正在写入...
Thread-2 写入完成，写入结果是 2
Thread-3 正在写入...
Thread-3 写入完成，写入结果是 3
Thread-4 正在写入...
Thread-4 写入完成，写入结果是 4
Thread-5 正在读...
Thread-7 正在读...
Thread-8 正在读...
Thread-6 正在读...
Thread-9 正在读...
Thread-5 读取完成，读取结果是 0
Thread-7 读取完成，读取结果是 2
Thread-8 读取完成，读取结果是 3
Thread-6 读取完成，读取结果是 1
Thread-9 读取完成，读取结果是 4

synchronized 和 Lock 有什么区别

原始结构

synchronized 是关键字属于 JVM 层面，反应在字节码上是 monitorenter 和 monitorexit，其底层是通过 monitor 对象来完成，其实 wait/notify 等方法也是依赖 monitor 对象只有在同步快或方法中才能调用 wait/notify 等方法
Lock 是具体类（java.util.concurrent.locks.Lock）是 api 层面的锁

使用方法

synchronized 不需要用户手动去释放锁，当 synchronized 代码执行完后系统会自动让线程释放对锁的占用
ReentrantLock 则需要用户手动的释放锁，若没有主动释放锁，可能导致出现死锁的现象，lock() 和 unlock()方法需要配合 try/finally 语句来完成

等待是否可中断

synchronized 不可中断，除非抛出异常或者正常运行完成
ReentrantLock 可中断，设置超时方法 tryLock(long timeout, TimeUnitunit)，lockInterruptibly() 放代码块中，调用 interrupt() 方法可中断

加锁是否公平

synchronized 非公平锁
ReentrantLock 默认非公平锁，构造方法中可以传入 boolean 值，true 为公平锁，false 为非公平锁

锁可以绑定多个 Condition

synchronized 没有 Condition
ReentrantLock 用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像 synchronized 要么随机唤醒一个线程要么唤醒全部线程

线程池

线程池用于多线程处理中，它可以根据系统的情况，可以有效控制线程执行的数量，优化运行效果。线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量，那么超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。

特点

线程复用
控制最大并发数量
管理线程

优点

降低资源消耗，通过重复利用已创建的线程来降低线程创建和销毁造成的消耗。
提高相应速度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅仅会消耗系统资源，还会降低体统的稳定性，使用线程可以进行统一分配，调优和监控。

创建方式

继承 Thread
实现 Runnable 接口
实现 Callable

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 在 FutureTask 中传入 Callable 的实现类
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                return 666;
            }
        });
        // 把 futureTask 放入线程中
        new Thread(futureTask).start();
        // 获取结果
        Integer res = futureTask.get();
        System.out.println(res);
    }
}

api架构

在这里插入图片描述

线程池种类

Executors.newSingleThreadExecutor()：只有一个线程的线程池，因此所有提交的任务是顺序执行
Executors.newCachedThreadPool()：线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过60秒内没执行，那么将被终止并从池中删除
Executors.newFixedThreadPool()：拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待
Executors.newScheduledThreadPool()：用来调度即将执行的任务的线程池
Executors.newWorkStealingPool()：newWorkStealingPool适合使用在很耗时的操作，但是newWorkStealingPool不是ThreadPoolExecutor的扩展，它是新的线程池类ForkJoinPool的扩展，但是都是在统一的一个Executors类中实现，由于能够合理的使用CPU进行对任务操作（并行操作），所以适合使用在很耗时的任务中

线程池参数

参数	作用
corePoolSize	核心线程池大小
maximumPoolSize	最大线程池大小
keepAliveTime	线程池中超过 corePoolSize 数目的空闲线程最大存活时间；可以allowCoreThreadTimeOut(true) 使得核心线程有效时间
TimeUnit	keepAliveTime 时间单位
workQueue	阻塞任务队列
threadFactory	新建线程工厂
RejectedExecutionHandler	当提交任务数超过 maxmumPoolSize+workQueue 之和时，任务会交给RejectedExecutionHandler 来处理

当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
当线程池达到corePoolSize时，新提交任务将被放入 workQueue 中，等待线程池中任务调度执行。
当workQueue已满，且 maximumPoolSize 大于 corePoolSize 时，新提交任务会创建新线程执行任务。
当提交任务数超过 maximumPoolSize 时，新提交任务由 RejectedExecutionHandler 处理。
当线程池中超过corePoolSize 线程，空闲时间达到 keepAliveTime 时，关闭空闲线程。
当设置allowCoreThreadTimeOut(true) 时，线程池中 corePoolSize 线程空闲时间达到 keepAliveTime 也将关闭。

拒绝策略

等待队列已满，同时线程池中的线程数达到了最大线程数，无法继续为新任务服务，将会采用拒绝策略处理

AbortPolicy：处理程序遭到拒绝将抛出运行时RejectedExecutionException
CallerRunsPolicy：线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度
DiscardPolicy：不能执行的任务将被删除
DiscardOldestPolicy：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序（如果再次失败，则重复此过程）

工作队列导致的内存溢出

Java中的BlockingQueue主要有两种实现，分别是ArrayBlockingQueue 和 LinkedBlockingQueue。

ArrayBlockingQueue是一个用数组实现的有界阻塞队列，必须设置容量。

LinkedBlockingQueue是一个用链表实现的有界阻塞队列，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。

这里的问题就出在：不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE。也就是说，如果我们不设置LinkedBlockingQueue的容量的话，其默认容量将会是Integer.MAX_VALUE。

而newFixedThreadPool中创建LinkedBlockingQueue时，并未指定容量。此时，LinkedBlockingQueue就是一个无边界队列，对于一个无边界队列来说，是可以不断的向队列中加入任务的，这种情况下就有可能因为任务过多而导致内存溢出问题。

上面提到的问题主要体现在newFixedThreadPool和newSingleThreadExecutor两个工厂方法上，并不是说newCachedThreadPool和newScheduledThreadPool这两个方法就安全了，这两种方式创建的最大线程数可能是Integer.MAX_VALUE，而创建这么多线程，必然就有可能导致OOM

自定义线程池

public class ThreadPoolExecutorDemo {

    public static void main(String[] args) {
        Executor executor = new ThreadPoolExecutor(
        	2, 
        	3, 
        	1L, 
        	TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(5), 
            Executors.defaultThreadFactory(), 
            new ThreadPoolExecutor.DiscardPolicy()
        );
    }
}

配置线程池线程数量

CPU 密集型

CPU 密集的意思是该任务需要大量的运算，而没有阻塞，CPU 一直全速运行。
CPU 密集型任务尽可能的少的线程数量，一般为 CPU 核数+ 1 个线程的线程池。

IO 密集型

由于 IO 密集型任务线程并不是一直在执行任务，可以多分配一点线程数，如 CPU * 2 。
也可以使用公式：CPU 核数 / (1 - 阻塞系数)；其中阻塞系数在 0.8 ～ 0.9 之间。

尚硅谷JUC学习笔记

我敲代码像把梭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC学习笔记（二）

volatile关键字JMM（Java Memory Model | Java内存模型）JMM是一种抽象的概念，不是真实存在的，它描述了一种规范，通过这组规范定义了程序中的访问方式JMM同步规定程序加锁前，必须读取主内存中的最新值到工作内存程序解锁前，必须将工作内存中的最新值写入到主内存加锁解锁是同一把锁原理由于 JVM 运行程序的实体是线程，而每个线程创建时 JVM 都会为其...
复制链接

扫一扫