JUC | 易学教程

volatile 关键字和内存可见性：
内存可见性（Memory Visibility）是指当①某个线程正在使用对象状态，而②另一个线程在同时修改该状态，需要③确保当一个线程修改了对象
状态后，④其他线程能够看到发生的状态变化。-----

在程序运行的时候，jvm会为每个线程分配一块独立的缓存，其中有一块主存（存放着共享资源），线程一用于修改共享数据，main线程用于读共享数据，
当线程一要对主存中共享数据的值进行改变的时候，先把共享数据读到缓存中来，然后在修改值，修改完后，将修改好后的值写会到主存中去，
在将修改后的值写入主存中前，此时main线程从主存中的数据读取出来，按理来说是先线程一执行修改数据，在main线程读取修改后的数据，
由于在线程一共享数据写入主存之前就执行main线程中读取共享数据，所以导致main线程缓存中的值是修改前的值（按代码逻辑来说是修改后的），
此时main线程缓存中存放的值是修改前的值，当调用了比较底层的代码（例如while(true)），执行效率非常高，高到main线程没有机会再次去主存中
读取一次数据（就是线程一修改后的，即逻辑正确情况）。
内存可见性问题是，当多个线程操作共享数据时，彼此不可见（由于首先读取线程的数据（共享数据）是不符合代码逻辑的，再加上某个底层代码执行效率太高，读取线程无法再次去主存中获取最新数据）

同步锁可以解决内存可见性问题，同步锁能保证每次去刷新缓存，保证缓存中数据和主存一致。（意味着效率非常低，这会导致共享资源永远只能被一个线程访问）
volatile 关键字：当多个线程进行操作共享数据时，可以保证内存中的数据可见。（可以理解为对他的操作（读写）就是在主存中完成的），相较于 synchronized 是一种较为轻量级的同步策略。比锁的效率高
（例如 class ThreadDemo implements Runnable { private volatile boolean flag = false; ）

注意：
1. volatile 不具备“互斥性” 当多个线程抢资源时，只有一个线程能获取资源，其他线程等资源被释放了才能获取，这就是互斥性
2. volatile 不能保证变量的“原子性” （不可分割）

原子变量和CAS算法
* 一、i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”
* int i = 10;
* i = i++; //10
*
* int temp = i;
* i = i + 1;
* i = temp;
其实i++是分为三步，当多个线程对共享数据进行该修改操作时，他们都可以同时获取到这个共享数据，如果同时进行修改可能出现线程一读取完还没写入主存的共享数据时，其他线程也读取了，这会导致数据逻辑异常。
如果对共享资源加上volatile也是没用的，他不能保证变量的原子性，因为这行代码分为三个操作，volatile只能保证单个操作时线程缓存中的数据和主存一致（可认为），当多个操作时，可能线程一在执行第二个操作（改），
这时线程二去读共享数据，从而导致数据逻辑异常。说白了就是有些java语句包含多个操作，这些操作在业务逻辑上应该是一致的（一步完成），但是在并发时无法保证在这个一致操作，从而导致原子变量的原子性无法保证。

*
* 二、原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
* 1. volatile 保证内存可见性
* 2. CAS（Compare-And-Swap）算法保证数据变量的原子性
* CAS 算法是硬件对于并发操作的支持
* CAS 包含了三个操作数：
* ①内存值 V 初次获取的共享数据的值
* ②预估值 A 在修改替换时向主存或者缓存中获取的值
* ③更新值 B
* 当且仅当 V == A 时， V = B; 否则，不会执行任何操作。这里可以把①看成是一个操作，②和③是同一个操作

解决方法：使用java.util.concurrent.atomic 包下提供了一些原子操作的常用类: 这些类满足原子变量的原子性，可直接使用
class AtomicDemo implements Runnable{
private AtomicInteger serialNumber = new AtomicInteger(0);
public int getSerialNumber(){
return serialNumber.getAndIncrement(); 相当于一个int类型的值a++
}

模拟CAS算法
package com.atguigu.juc;
/*
* 模拟 CAS 算法
*/
public class TestCompareAndSwap {
public static void main(String[] args) {
final CompareAndSwap cas = new CompareAndSwap();
for (int i = 0; i < 10; i++) {
new Thread(new Runnable() {
@Override
public void run() {
int expectedValue = cas.get();
boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
System.out.println(b);
}
}).start();
}
}
}
class CompareAndSwap{
private int value;
//获取内存值
public synchronized int get(){
return value;
}
//比较
public synchronized int compareAndSwap(int expectedValue, int newValue){
int oldValue = value;
if(oldValue == expectedValue){
this.value = newValue;
}
return oldValue;
}
//设置
public synchronized boolean compareAndSet(int expectedValue, int newValue){
return expectedValue == compareAndSwap(expectedValue, newValue);
}
}

ConcurrentHashMap 锁分段机制：
复合操作：
“若不存在则添加”
“若存在则删除”
if(!table.contants()){
table.put();
}
Hashtable（这个线程安全是把整个map集合给锁住了）在这些操作面前也是线程不安全的

ConcurrentHashMap怎么用，map怎么用ConcurrentHashMap就怎么用，在1.9后使用的是CAS算法
ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对与多线程的操作，介于 HashMap 与 Hashtable 之间。内部采用“锁分段”机制替代 Hashtable 的独占锁。进而提高性能。

Collections这个工具类可以使得线程不安全的变成安全的原理是在集合类的每个方法面前加个synchronize，变成同步方法，变成线程安全的了。

CopyOnWriteArrayList在每次写入时，在底层完成一个复制，复制一个新的列表在修改，和其他操作互相不干涉，并发修改异常不会发生，效率会低下，添加操作多时不适合选这个；迭代操作多时，于此有并发迭代时选择这个。

CountDownLatch 闭锁：
闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行：
 确保某个计算在其需要的所有资源都被初始化之后才继续执行;
 确保某个服务在其依赖的所有其他服务都已经启动之后才启动;
 等待直到某个操作所有参与者都准备就绪再继续执行。
/*
* CountDownLatch ：闭锁，在完成某些运算是，只有其他所有线程的运算全部完成，当前运算才继续执行
*这里可以设定多个Runnable实现类（线程执行），但是这些Runnable实现类（多个线程）共用一个CountDownLatch，当这些线程执行完了，CountDownLatch减一。
*/
public class TestCountDownLatch {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(50);
LatchDemo ld = new LatchDemo(latch);
long start = System.currentTimeMillis();
for (int i = 0; i < 50; i++) {
new Thread(ld).start();
}
//这里是用闭锁使得当前线程停止，直到latch的计数到0为止，在执行当前线程
try {
latch.await();
} catch (InterruptedException e) {
}
long end = System.currentTimeMillis();
System.out.println("耗费时间为：" + (end - start));
}
}
class LatchDemo implements Runnable {
private CountDownLatch latch;
public LatchDemo(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void run() {
try {
for (int i = 0; i < 50000; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
} finally {
latch.countDown();//这里用于标记当前线程已经执行完毕，那么闭锁减一
}
}
}

实现 Callable 接口：
/*
* 一、创建执行线程的方式三：实现 Callable 接口。相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常。
*
* 二、执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。 FutureTask 是 Future 接口的实现类
*/
public class TestCallable {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
//1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
FutureTask<Integer> result = new FutureTask<>(td); //将线程资源放入FutureTask中，返回FutureTask，这个是返回的线程执行结果
new Thread(result).start();
//2.接收线程运算后的结果
try {
Integer sum = result.get(); //FutureTask 可用于闭锁，只有当对应的线程资源（实现了Callable的类）执行完了后，才可以通过result调用get方法返回返回值，若该线程未完成，当前线程处于等待。
System.out.println(sum);
System.out.println("------------------------------------");
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
class ThreadDemo implements Callable<Integer>{
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100000; i++) {
sum += i;
}
return sum;
}
}

Lock 同步锁：
ReentrantLock 实现了 Lock 接口，并提供了与synchronized 相同的互斥性和内存可见性。但相较于synchronized 提供了更高的处理锁的灵活性。
/*
* 一、用于解决多线程安全问题的方式：
*
* synchronized:隐式锁
* 1. 同步代码块
*
* 2. 同步方法
*
* jdk 1.5 后：
* 3. 同步锁 Lock 其实就相当于在上锁和释放锁的地方，加上同步代码块，他能使这块代码不准多个线程执行，最多只有一个线程执行。而同步代码块和同步方法都是看该线程是否有同步监视器，有才能执行。
* 注意：是一个显示锁，需要通过 lock() 方法上锁，必须通过 unlock() 方法进行释放锁
*/
public class TestLock {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(ticket, "1号窗口").start();
new Thread(ticket, "2号窗口").start();
new Thread(ticket, "3号窗口").start();
}
}
class Ticket implements Runnable{
private int tick = 100;
private Lock lock = new ReentrantLock();
@Override
public void run() {
while(true){
lock.lock(); //上锁
try{
if(tick > 0){
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName() + " 完成售票，余票为：" + --tick);
}
}finally{
lock.unlock(); //释放锁
}
}
}
}

Condition 控制线程通信：
wait()：导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程，调用wait()方法的当前线程会释放对该同步监视器的锁定。
notify()：唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对该同步监视器的锁定后（使用wait()方法），才可以执行被唤醒的线程。
notifyAll()：唤醒在此同步监视器上等待的所有线程。只有当前线程放弃对该同步监视器的锁定后（使用wait()方法），才可以执行被唤醒的线程。
/*
* 生产者和消费者案例
*/
public class TestProductorAndConsumer {
public static void main(String[] args) {
Clerk clerk = new Clerk(); //线程执行时共享的资源，一般同步方法都在共享资源里面定义，同时调用wait()，notify()，notifyAll()都是同步监视器调用，也是在共享资源里面（同步代码块，同步方法）调用
Productor pro = new Productor(clerk); //线程执行内容（实现Runnable接口）
Consumer cus = new Consumer(clerk); //
new Thread(pro, "生产者 A").start(); //多个生产者线程共用一个线程执行内容（这样就可以让多个线程执行同样的线程内容）
new Thread(cus, "消费者 B").start(); //多个消费者线程共用一个线程执行内容（这样就可以让多个线程执行同样的线程内容）
new Thread(pro, "生产者 C").start();
new Thread(cus, "消费者 D").start();
}
}
//店员
class Clerk{
private int product = 0;
//进货
public synchronized void get(){//循环次数：0
while(product >= 1){//为了避免虚假唤醒问题，应该总是使用在循环中
System.out.println("产品已满！");
try {
this.wait();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : " + ++product);
this.notifyAll();
}
//卖货
public synchronized void sale(){//product = 0; 循环次数：0
while(product <= 0){
System.out.println("缺货！");
try {
this.wait();//比如说这里等待的话，在同步方法里面，this就是同步监视器，要让其等待的话就用同步监视器的wait()方法
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : " + --product);
this.notifyAll();//比如说这里唤醒的话，在同步方法里面，this就是同步监视器，唤醒的话必须使用同步监视器的notify()，notifyAll()方法
}
}
//生产者
class Productor implements Runnable{
private Clerk clerk;

public Productor(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
}
clerk.get();
}
}
}
//消费者
class Consumer implements Runnable{
private Clerk clerk;

public Consumer(Clerk clerk) {
this.clerk = clerk;
}

@Override
public void run() {
for (int i = 0; i < 20; i++) {
clerk.sale();
}
}
}

Condition 控制线程通信：使用同步锁
以上面的例子为例：
仅仅修改了Clerk类
class Clerk {
private int product = 0;
private Lock lock = new ReentrantLock(); //在共享资源需要用到锁的类定义锁对象ReentrantLock
private Condition condition = lock.newCondition(); //定义控制方法锁对象的Condition类
// 进货
public void get() {
lock.lock(); // 上锁和释放锁的地方相当定义同步代码块
try {
while(product >= 1) { // 为了避免虚假唤醒，应该总是使用在循环中。
System.out.println("产品已满！");
try {
condition.await(); //使用condition.await()取代同步监视器.await()方法
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : "
+ ++product);
condition.signalAll(); //使用condition.signalAll()取代同步监视器.notifyAll()方法
} finally {
lock.unlock();//释放锁
}
}
// 卖货
public void sale() {
lock.lock(); // 上锁和释放锁的地方相当定义同步代码块
try {
while(product <= 0) {
System.out.println("缺货！");
try {
condition.await(); //使用condition.await()取代同步监视器.await()方法
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName() + " : "
+ --product);
condition.signalAll(); //使用condition.signalAll()取代同步监视器.notifyAll()方法
} finally {
lock.unlock();//释放锁
}
}
}

线程按序交替：
/*
* 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。
* 如：ABCABCABC…… 依次递归
*/
public class TestABCAlternate {
public static void main(String[] args) {
AlternateDemo ad = new AlternateDemo();
new Thread(new Runnable() { //执行loopA方法20次
@Override
public void run() { //线程执行内容
for (int i = 1; i <= 20; i++) {
ad.loopA(i);
}
}
}, "A").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 20; i++) {
ad.loopB(i);
}
}
}, "B").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 20; i++) {
ad.loopC(i);
System.out.println("-----------------------------------");
}
}
}, "C").start();
}
}
class AlternateDemo{
private int number = 1; //当前正在执行线程的标记
private Lock lock = new ReentrantLock(); //共用同步锁
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
/**
* @param totalLoop : 循环第几轮
*/
public void loopA(int totalLoop){
lock.lock();
try {
//1. 判断 number表示接下来执行的线程
if(number != 1){
condition1.await();
}
//2. 打印 //打印一次当前线程名一次
for (int i = 1; i <= 1; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
}
//3. 唤醒
number = 2; //打印完了A线程后，告诉他下个执行的线程是B
condition2.signal(); //这里他只会去唤醒condition2.await()方法锁住的线程，也就是相当于condition2.signal()只能解决condition2.await();导致的线程等待，不能解决condition3.await()
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void loopB(int totalLoop){
lock.lock();
try {
//1. 判断
if(number != 2){
condition2.await();
}
//2. 打印
for (int i = 1; i <= 1; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
}
//3. 唤醒
number = 3;
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void loopC(int totalLoop){
lock.lock();
try {
//1. 判断
if(number != 3){
condition3.await();
}
//2. 打印
for (int i = 1; i <= 1; i++) {
System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
}
//3. 唤醒
number = 1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
Condition对象的理解：在Lock对象时，用Lock来上锁，用Lock解锁，Condition对象是来源于lock.newCondition()的对象，Condition是可以在Lock来上锁（lock.lock()）后（还没调用lock.unlock()）去调用condition1.await()，
那么在调用condition1.await()方法的线程中，该线程会释放对该同步监视器的锁定，只有当调用condition1.signal()才能唤醒该线程，唤醒该线程意味着该线程可以重新获得同步监视器，继续执行下面的代码。
来自于同一个Lock对象的Condition对象，是可以在Lock上锁后，释放锁前，去用Condition对象去调用await()和signal()方法，即使Condition对象不同也行。
被唤醒的线程，他出于等待资源的状态，可以随时执行，若执行下条语句处于同步锁之中，那么他同样会获取同步监视器。
注意：condition1.await()可以使得当前线程处于沉睡状态，condition1.signal()只能使指定的线程（调用condition1.await()使它沉睡的线程）唤醒。
this.signal()方法和condition.signal()方法的不同之处：this.signal()随机唤醒线程（调用过this.await()方法的线程），而condition1.signal()只能唤醒线程（调用过ondition1.await()方法的线程），这也是Condition优势所在，
还有可以有多个condition对象依赖在同一个lock对象上，使得多个不同级别的线程可以在同一共享资源上面实现随意调度（指定他们的执行顺序）。

ReadWriteLock 读写锁：
-ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。
-ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。
ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性可以完全不需要考虑加锁操作。
/*
* 1. ReadWriteLock : 读写锁
*
* 写写/读写需要“互斥”
* 读读不需要互斥
*
*/
public class TestReadWriteLock {
public static void main(String[] args) {
ReadWriteLockDemo rw = new ReadWriteLockDemo();
new Thread(new Runnable() {
@Override
public void run() {
rw.set((int)(Math.random() * 101));
}
}, "Write:").start();
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
@Override
public void run() {
rw.get();
}
}).start();
}
}
}
class ReadWriteLockDemo{
private int number = 0;
private ReadWriteLock lock = new ReentrantReadWriteLock();
//读
public void get(){
lock.readLock().lock(); //上锁上了读锁后，允许多个线程同时执行该方法
try{
System.out.println(Thread.currentThread().getName() + " : " + number);
}finally{
lock.readLock().unlock(); //释放锁
}
}
//写
public void set(int number){
lock.writeLock().lock(); //上了写锁后，就变成独占锁了，最多允许一个线程执行该方法
try{
System.out.println(Thread.currentThread().getName());
this.number = number;
}finally{
lock.writeLock().unlock();
}
}
}

线程八锁：
• 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻
内，只能有唯一一个线程去访问这些synchronized方法
• 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
• 加个普通方法后发现和同步锁无关
• 换成两个对象后，不是同一把锁了，情况立刻变化。
• 都换成静态同步方法后，情况又变化
• 所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获
取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非
静态同步方法释放锁就可以获取他们自己的锁。
• 所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个
静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同
步方法之间，只要它们同一个类的实例对象！
/*
* 题目：判断打印的 "one" or "two" ？
*
* 1. 两个普通同步方法，两个线程，标准打印，打印? //one two
* 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two
* 3. 新增普通方法 getThree() , 打印? //three one two
* 4. 两个普通同步方法，两个 Number 对象，打印? //two one
* 5. 修改 getOne() 为静态同步方法，打印? //two one
* 6. 修改两个方法均为静态同步方法，一个 Number 对象? //one two
* 7. 一个静态同步方法，一个非静态同步方法，两个 Number 对象? //two one
* 8. 两个静态同步方法，两个 Number 对象? //one two
*
* 线程八锁的关键：
* ①非静态方法的锁默认为 this, 静态方法的锁为对应的 Class 实例
* ②某一个时刻内，只能有一个线程持有锁，无论几个方法。
* 普通方法不会受到锁的限制，也就是说某个实例或者类被一个其他线程所持有锁（实例或类被锁住），非同步方法（非同步类方法和非同步实例方法）照样可以在其他线程中执行。
*/
public class TestThread8Monitor {
public static void main(String[] args) {
Number number = new Number();
Number number2 = new Number();
new Thread(new Runnable() {
@Override
public void run() {
number.getOne();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// number.getTwo();
number2.getTwo();
}
}).start();
/*new Thread(new Runnable() {
@Override
public void run() {
number.getThree();
}
}).start();*/
}
}
class Number{
public static synchronized void getOne(){//Number.class
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
}
System.out.println("one");
}
public synchronized void getTwo(){//this
System.out.println("two");
}
public void getThree(){
System.out.println("three");
}
}

线程池：
/*
* 一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。
*
* 二、线程池的体系结构：
* java.util.concurrent.Executor : 负责线程的使用与调度的根接口
* |--**ExecutorService 子接口: 线程池的主要接口
* |--ThreadPoolExecutor 线程池的实现类
* |--ScheduledExecutorService 子接口：负责线程的调度
* |--ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor，实现 ScheduledExecutorService
*
* 三、工具类 : Executors
* ExecutorService newFixedThreadPool() : 创建固定大小的线程池
* ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
* ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程
*
* ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。
*/
public class TestThreadPool {
public static void main(String[] args) throws Exception {
//1. 创建线程池
ExecutorService pool = Executors.newFixedThreadPool(5);
List<Future<Integer>> list = new ArrayList<>(); //创建一个list用于存放线程返回值
for (int i = 0; i < 10; i++) { //循环创建线程并且放入线程池中，并将线程结果值返回，然后把线程结果值统一放入list中去
Future<Integer> future = pool.submit(new Callable<Integer>(){ //也可以根据接口写匿名内部类
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
sum += i;
}
return sum;
}
});
list.add(future); //将返回值放入list中
}
pool.shutdown(); //关闭线程池
for (Future<Integer> future : list) {
System.out.println(future.get()); //遍历线程返回值
}
/*ThreadPoolDemo tpd = new ThreadPoolDemo();
//2. 为线程池中的线程分配任务
for (int i = 0; i < 10; i++) {
pool.submit(tpd);
}
//3. 关闭线程池
pool.shutdown();*/
}
// new Thread(tpd).start();
// new Thread(tpd).start();
}
class ThreadPoolDemo implements Runnable{
private int i = 0;
@Override
public void run() {
while(i <= 100){
System.out.println(Thread.currentThread().getName() + " : " + i++);
}
}
}

线程调度：
/*
* 一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁额外开销，提高了响应的速度。
*
* 二、线程池的体系结构：
* java.util.concurrent.Executor : 负责线程的使用与调度的根接口
* |--**ExecutorService 子接口: 线程池的主要接口
* |--ThreadPoolExecutor 线程池的实现类
* |--ScheduledExecutorService 子接口：负责线程的调度
* |--ScheduledThreadPoolExecutor ：继承 ThreadPoolExecutor，实现 ScheduledExecutorService
*
* 三、工具类 : Executors
* ExecutorService newFixedThreadPool() : 创建固定大小的线程池
* ExecutorService newCachedThreadPool() : 缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。
* ExecutorService newSingleThreadExecutor() : 创建单个线程池。线程池中只有一个线程
*
* ScheduledExecutorService newScheduledThreadPool() : 创建固定大小的线程，可以延迟或定时的执行任务。
*/
public class TestScheduledThreadPool {
public static void main(String[] args) throws Exception {
ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
for (int i = 0; i < 5; i++) {
Future<Integer> result = pool.schedule(new Callable<Integer>(){
@Override
public Integer call() throws Exception {
int num = new Random().nextInt(100);//生成随机数
System.out.println(Thread.currentThread().getName() + " : " + num);
return num;
}
}, 1, TimeUnit.SECONDS); // 设置延迟多长时间执行该线程，自创建线程开始算，设置多少，就会延迟多长时间执行线程中的内容。
System.out.println(result.get());
}
pool.shutdown();
}
}

来源：https://www.cnblogs.com/wx543572577/p/10884474.html

标签

juc

线程

volatile