JUC详解(一)

本次笔记来自狂神说和尚硅谷

JUC(一)

  • 1.什么是JUC?
    • 1.1 概念
    • 1.2 注意点
    • 1.3 题外话
  • 2.线程的几个状态
    • 2.1 6个状态
    • 2.2 wait/sleep区别
  • 3.juc方式--Lock锁
    • 3.1 传统synchronized
    • 3.2 Lock接口(公平锁和非公平锁)
    • 3.3 synchronized 和 Lock接口区别
    • 3.4 代码
  • 4.生产者和消费者问题
    • 4.1 多线程编程步骤:
    • 4.2 生产者和消费者问题Synchronized版 wait notify
    • 4.3 问题:虚假唤醒
    • 4.4 JUC版的生产者和消费者问题
    • 4.5 定制化通信
  • 5. 8锁现象
    • 5.1 标准情况下,两个线程先打印发短信还是打电话?
    • 5.2 send延迟4秒,两个线程先打印发短信还是打电话?
    • 5.3 增加了一个普通方法后! 先执行发短信还是Hello
    • 5.4 两个对象,两个同步方法, 发短信还是打电话?
    • 5.5 增加两个静态的同步方法,只有一个对象,先打印发短信?打电话?
    • 5.6 两个对象!增加两个静态的同步方法,先打印发短信?打电话?
    • 5.7 1个静态的同步方法,1个普通的同步方法,一个对象,先打印发短信?打电话?
    • 5.8 1个静态的同步方法,1个普通的同步方法,两个对象,先打印发短信?打电话?
    • 5.9 synchronized实现同步的基础
  • 6.集合类不安全
    • 6.1 List CopyOnWriteArrayList
    • 6.2 Set CopyOnWriteArraySet
    • 6.3 Map ConcurrentHashMap
  • 7.Callable
    • 7.1 与Runnable的区别
    • 7.2 Callable怎么启动
    • 7.3 代码

1.什么是JUC?

1.1 概念

JUC就是java.util .concurrent等等工具包的简称,如下:
这是一个处理线程的工具包。

java.util.concurrent 主讲并发相关的和Callable([kənˈkʌrənt])
java.util.concurrent.atomic主讲 原子性([əˈtɒmɪk])
java.util.concurrent.locks 主讲锁

1.2 注意点

idea坏境必须都要一致8版本的,
不然用lambda表达式等等java8新特性用不了。

1.3 题外话

1.线程和进程
进程就是一个程序
一个进程往往可以包含多个线程,至少包含一个!

2.Java默认有几个线程?
2个,mian(主线程)、 GC(垃圾回收机制)。

3.java真的可以开启线程吗?
》不可以

因为java 没有权限去开线程,
只能通过本地方法去调 thread.java里的private native void start0();,
去调底层的c++ ,
java无法直接操作硬件它是运行在虚拟机之上 。

4.并发和并行
并发(多线程操作同一个资源)》CPU单核
并发编程的本质: 充分利用CPU的资源

并行(多个人一起行走)》CPU多核

用最高性能可以使用线程池

2.线程的几个状态

2.1 6个状态

Thread.State

public enum State {
//新生
    NEW,
//运行
    RUNNABLE,
//阻塞
    BLOCKED,
//等待,死死地等
    WAITING,
//超时等待,过时不候
    TIMED_WAITING,
//终止
    TERMINATED;
}

2.2 wait/sleep区别

1.来自不同的类
wait => Object
sleep => Thread

2.关于锁的释放
wait会释放锁, sleep睡觉了, 抱着锁睡觉,不会释放

3.使用的范围是不同的
wait必须在同步代码块中
sleep可以在任何地方睡

3.juc方式–Lock锁

3.1 传统synchronized

synchronized 本质:队列 ,锁

3.2 Lock接口(公平锁和非公平锁)

源码

  Lock l = ...; l.lock(); 
  try { 
  // access the resource protected by this lock  
  } 
  finally { l.unlock(); }

l.lock() 加锁
l.unlock() 解锁

接口的三个实现类
可重入锁(常用) ReentrantLock
读锁 ReentrantReadWriteLock.ReadLock
写锁 ReentrantReadWriteLock.WriteLock

Lock lock = new ReentrantLock();

ReentrantLock里面的源码

public ReentrantLock() {  sync = new NonfairSync(); } 

默认是非公平锁

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
} 

三元表达式:如果为true那就是公平锁,false即非公平锁

NonfairSync非公平锁
十分不公平:可以插队(默认),谁抢到就是谁的

但一般这个是公平锁 3h 3s 3s等3h
可能会出现一个线程全执行完了,其他线程饿死的情况
好处是效率高

FairSync公平锁
十分公平:不能够插队,必须先来后到

效率相对较低,相对于就是底层会礼貌的问一句,有个动作

3.3 synchronized 和 Lock接口区别

1.Synchronized内置的Java关键字 ,Lock 是一个Java类
2.Synchronized 无法判断获取锁的状态,Lyock可以判断是否获取到了锁
3.Synchronized 会自动释放锁, lock必须要手动释放锁!如果不释放锁,死锁
4.Synchronized 线程1 (获得锁,阻塞)、线程2 (等待,傻傻的等) ;
Lock锁就不一定会等待下去;
lock.tryLock() 尝试获取锁 等不到就结束了
5.Synchronized 可重 入锁,不可以中断的,非公平;
Lock ,可重入锁,可以判断锁,非公平(可以自己设置) ;
6.Synchronized 适 合锁少量的代码同步问题, Lock适合锁大量的同步代码!
Lock可以提高多个线程进行读操作的效率

3.4 代码

synchronized

public class Test01 {
    public static void main(String[] args) {
    //并发:多线程操作同一个资源类
        Ticket ticket = new Ticket();
        new Thread(()->{
            for (int i = 0; i < 40; i++) {
                ticket.sale();
            }
            //检40次票
        },"A").start();
        //匿名内部类使用lambda表达式
        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();
        //一共有三个线程
    }
}
//资源类 oop
class Ticket{
    private int number = 30;
    //卖票的方式
    public synchronized void sale(){
        if (number > 0 ){
            System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票,剩余" + number);
        }
    }
}

Lock

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

public class Test02 {
    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        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();
    }
}

class Ticket2{
    private int number = 30;
    Lock lock = new ReentrantLock();
    public  void sale(){
        lock.lock();//加锁
        try {
            if (number > 0 ){
                System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票,剩余" + number);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//解锁
        }
    }
}

4.生产者和消费者问题

4.1 多线程编程步骤:

第一步创建资源类,在资源类创建属性和操作方法
第二步在资源类操作方法(1)判断(2)干活(3)通知
第三步创建多个线程,调用资源类的操作方法
第四步:防止虚假唤醒问题

4.2 生产者和消费者问题Synchronized版 wait notify

线程之间的通信问题
生产者和消费者问题! 等待唤醒,通知唤醒
线程交替执行 A B 操作同一个变量 num=0
A num+1
B num-1

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();//+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();//+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
class Data{
    private int number = 0;
    //+1
    public synchronized void increment() throws InterruptedException {
        if (number!=0){
            this.wait(); //等待 会释放锁 别的线程抢
        }  
        number++;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程,我+1完毕了
        this.notifyAll();
    }
    //-1
    public synchronized void decrement() throws InterruptedException {
        if (number==0){
            this.wait(); //等待
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "=>" + number);
        //通知其他线程,我-1完毕了
        this.notifyAll();
    }
}

A=>1
B=>0
A=>1
B=>0
… 》一共执行20次

4.3 问题:虚假唤醒

问题存在,如果有ABCD 4个线程就会出现错误 !(虚假唤醒)
wait的特点 :在哪里睡,就在哪里醒
原因:
假设线程c之前等待了,但后来又被唤醒了
会往下走,if只判断一次,不会生效。

详细原因:
虚假唤醒,实质上是一次唤醒了所有线程,而CPU执行了本来不该被执行的线程,比如库存为0后,本想让CPU执行生产者线程,但是CPU却执行了另一个被唤醒的消费者,而该消费者没有重新去判断库存,直接进行消费。

解决方法:
使用while,在解除阻塞时,需要直到满足条件才会执行接下来的代码。

虚假唤醒(wait)的概念:
线程也可以唤醒,而不会被通知,中断或超时,即所谓的虛假唤醒。虽然这在实践中很少会发生 ,但应用程序必须通过测试应该使线程被唤醒的条件来防范,并且如果条件不满足则继续等待。换句话说, 等待应该总是出现在循环中。

synchronized (obj) {
		while (<condition does not hold>)
				obj.wait(timeout);// Perform action appropriate to condition
}

虚假唤醒就是当一个条件满足时,很多线程都被唤醒了,
但是只有其中部分是有用的唤醒,其它的唤醒都是无用功
》正确做法 if改为while判断

(1)if判断流水线状态为空时,线程被阻塞,
这时if判断就完成了,线程被唤醒后直接执行线程剩余操作

(2)while判断流水线状态为空时,线程被阻塞,
这时的while循环没有完成,线程被唤醒后会先进行while判断

4.4 JUC版的生产者和消费者问题

》通过Lock类找到Condition

Lock替换synchronized方法和语句的使用,
Condition取代了对象监视器方法的使用。

Condition就等价于 wait和notify,里面专属的是await和signal

第一版代码:

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

public class B {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();//+1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();//-1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
       //省略CD 线程
    }
}

class Data2{
    private int number = 0;
    Lock lock = new ReentrantLock();//可重入锁
    Condition condition = lock.newCondition();
    //+1
    public void increment() throws InterruptedException {
        lock.lock();//上锁
        try {
            //业务代码 判断
            while (number!=0){
                condition.await();  //等待
            }
            //干活
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程,我+1完毕了
            condition.signalAll();//唤醒全部
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//开锁
        }

    }
    //-1
    public  void decrement() throws InterruptedException {
        lock.lock();//上锁
        try {
            //业务代码
            while (number==0){
                condition.await();  //等待
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程,我-1完毕了
            condition.signalAll();//唤醒全部
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();//开锁
        }
    }
}

注意这个结果虽然可以了,但还是有问题
它是随机的状态生成 ,几个线程不规律
如何让他有序执行 先A 再B 再C 再D

4.5 定制化通信

解决方法: Condition精准的通知和唤醒线程
给每个线程定义一个标识位,来完成定制化通信

第二版代码

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//A 执行完 调 B,B 执行完 调 C,C 执行完 调 A
public class C {
    public static void main(String[] args) {
        Data3 data = new Data3();
        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 Data3{
    private Lock lock = new ReentrantLock();//锁
    private  Condition condition1 = lock.newCondition();//同步监视器
    private  Condition condition2 = lock.newCondition();//同步监视器
    private  Condition condition3 = lock.newCondition();//同步监视器
    //通过condition多个监视器来精确的通知执行访问顺序
    private int number = 1;//1》A 2》B 3》C 判断的类
    public void printA(){
        lock.lock();
        try {//业务,判断-》执行-》通知
            while (number!=1){
                condition1.await();//等待
            }
            System.out.println(Thread.currentThread().getName() + "=>AAA");
            //唤醒,唤醒指定的人,B
            number = 2;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {//业务,判断-》执行-》通知
            while (number!=2){
                condition2.await();//等待
            }
            System.out.println(Thread.currentThread().getName() + "=>BBB");
            //唤醒,唤醒指定的人,C
            number = 3;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {//业务,判断-》执行-》通知
            while (number!=3){
                condition3.await();//等待
            }
            System.out.println(Thread.currentThread().getName() + "=>CCC");
            //唤醒,唤醒指定的人,A
            number = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

A=>AAA
B=>BBB
C=>CCC
。。。

5. 8锁现象

如何判断锁的是谁!是否是同一把锁,锁的范围
对象、Class

8锁,关于锁的8个问题

5.1 标准情况下,两个线程先打印发短信还是打电话?

》1/发短信 2/打电话

5.2 send延迟4秒,两个线程先打印发短信还是打电话?

》1/发短信 2/打电话

总结:
这边synchronized 锁的是当前的对象(this)
》调用send方法时,把当前对象锁住了,
call方法只能等待,结束之后才能调用
》因为是对象锁,一个对象只有一把锁,是同一把锁

import java.util.concurrent.TimeUnit;
public class Test1 {
    public static void main(String[] args) throws Exception {
        Phone phone = new Phone();
        //并不是因为A先执行的,而是有锁的存在
        new Thread(()->{
            try {
                phone.send();
            } catch (Exception e) { e.printStackTrace(); }
        },"A").start();
        TimeUnit.SECONDS.sleep(1);
        //等价于 Thread.sleep(1000)
//start方法什么时候创建不确定,所以加sleep,因为调了sleep,所以一定是唯一的值
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    // synchronized 锁的对象是方法的调用者!
    // 两个方法用的是同一个锁,谁先拿到谁执行!
    public synchronized void send() throws Exception {
        TimeUnit.SECONDS.sleep(4);//延迟4秒
        System.out.println("发短信");
    }
    public synchronized void call(){ System.out.println("打电话"); }
}

5.3 增加了一个普通方法后! 先执行发短信还是Hello

》1/hello 2/发短信

总结:
hello就是个普通方法和锁无关 所以先执行

import java.util.concurrent.TimeUnit;
public class Test2 {
    public static void main(String[] args) throws Exception {
        Phone2 phone = new Phone2();
        new Thread(()->{
            try {
                phone.send();
            } catch (Exception e) { e.printStackTrace(); }
        },"A").start();
        //锁的存在
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone.hello();
        },"B").start();
    }
}
class Phone2{
    // synchronized 锁的对象是方法的调用者!
    public synchronized void send() throws Exception {
        TimeUnit.SECONDS.sleep(4);//延迟4秒
        System.out.println("发短信");
    }
    //这里没有锁!不是同步方法,不受锁的影响
    public void hello(){ System.out.println("hello"); }
}

5.4 两个对象,两个同步方法, 发短信还是打电话?

》1/打电话 2/发短信

总结:
不是同一把锁 因为send方法等了四秒所以晚输出
和上厕所一样各上各的

import java.util.concurrent.TimeUnit;
public class Test3 {
    public static void main(String[] args) throws Exception {
        //两个对象 两个调用者 两个锁 按时间来的
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{
            try {
                phone1.send();
            } catch (Exception e) {  e.printStackTrace(); }
        },"A").start();
        //锁的存在
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone3{
    // synchronized 锁的对象是方法的调用者!
    public synchronized void send() throws Exception {
        TimeUnit.SECONDS.sleep(4);//延迟4秒
        System.out.println("发短信");
    }
    public synchronized void call(){ System.out.println("打电话"); }
}

5.5 增加两个静态的同步方法,只有一个对象,先打印发短信?打电话?

》1/发短信 2/打电话

5.6 两个对象!增加两个静态的同步方法,先打印发短信?打电话?

》1/发短信 2/打电话

总结:
锁的是当前类的Class对象(字节码)
》顺序是因为static 不能说一定是synchronized

import java.util.concurrent.TimeUnit;
public class Test4 {
    public static void main(String[] args) throws Exception {
        //两个对象的Class类模板只有一个,static, 锁的是CLass
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(()->{
            try {
                phone1.send();
            } catch (InterruptedException e) { e.printStackTrace(); }
        },"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
// Phone4唯一的一个 Class对象
class Phone4{
    // synchronized 锁的对象是方法的调用者!
    // static 静态方法
    //类一加载就有了!锁的是Class  class模板
    public static synchronized void send() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);//延迟4秒
        System.out.println("发短信");
    }
    public static synchronized void call(){ System.out.println("打电话"); }
}

5.7 1个静态的同步方法,1个普通的同步方法,一个对象,先打印发短信?打电话?

》1/打电话2/发短信

5.8 1个静态的同步方法,1个普通的同步方法,两个对象,先打印发短信?打电话?

》1/打电话2/发短信

总结:
1.不是同一把锁
》两个方法用的不是同一个锁 不需要去等待 最快最先
2.synchronized对象锁,就是看对象是不是同一个
是的话谁在前面先拿到锁 谁就先执行里面的内容

3.如果有static修饰方法,都是代表class类对象,
即谁先拿到锁谁先执行内容

import java.util.concurrent.TimeUnit;
public class Test5 {
    public static void main(String[] args) throws Exception {
        ///两个对象的Class类模板只有一个,static, 锁的是CLass
        Phone5 phone1 = new Phone5();
        Phone5 phone2 = new Phone5();
        new Thread(()->{
            try {
                phone1.send();
            } catch (Exception e) { e.printStackTrace(); }
        },"A").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone5{
    // 静态的同步方法 锁的是Class类模板
    public static synchronized void send() throws Exception {
        TimeUnit.SECONDS.sleep(4);//延迟4秒
        System.out.println("发短信");
    }
    //普通的同步方法   锁的调用者
    public synchronized void call(){ System.out.println("打电话"); }
}

5.9 synchronized实现同步的基础

Java中的每一个对象都可以作为锁。

具体为以下3种形式:
对于普通同步方法,锁是当前实例对象。
对于静态同步方法,锁是当前类的Class对象。
对于同步方法块,锁是Synchonized括号里配置的对象

6.集合类不安全

只要在并发下,用默认的集合,在集合里面都会出现这个错
java.util.ConcurrentModificationException 并发修改异常!

虽然有时候可能没出问题,但不是就代表多线程没问题

6.1 List CopyOnWriteArrayList

解决方法:
1.List list = new Vector<>(); vector默认就是安全的,里面有Synchronized
但这个太老了,一般不用
2.List list = collections.synchronizedList(new ArrayList<>());(工具类)
用工具类让它变得安全
3.List list = new CopyOnWriteArrayList<>(); JUC解决方案 更牛逼
CopyOnWrite 》写入时复制 简称Cow,它是计算机程序设计领域的一种优化策略;
注意:
多个线程调用的时候,list是唯一的,读取的时候是固定的,但写入的时候会存在覆盖的行为,在写入的时候避免覆盖,造成数据问题! 所以需要用到CopyOnWrite,写入的时候复制一份,写完在插进去

CopyOnWriteArrayList 比 Vector 好在哪里?
Vector 用到 Synchronized 性能比较低
而前者用到了lock锁,效率和性能更高

代码:

import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
public class ListTest {
    public static void main(String[] args) {    
        List<String> list= new CopyOnWriteArrayList<>();
        for (int i = 0; i < 10; i++) {
            //10个线程去调用
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));//生成随机字符串
                System.out.println(list);
            },String.valueOf(i)).start();
            //String.valueOf(int i) : 将 int 变量 i 转换成字符串
        }
    }
}

结果:(随机)
JUC详解(一)_第1张图片

6.2 Set CopyOnWriteArraySet

HashSet set = new HashSet<>();可能就会报错。

解决方法:
1.Set set = Collections.synchronizedSet(new HashSet<>());
2. Set set = new CopyOnWriteArraySet<>();

import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
public class SetList {
    public static void main(String[] args) {
        Set<String> set = new CopyOnWriteArraySet<>();
        for (int i = 0; i < 30; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));//生成随机字符串
                System.out.println(set);
            },String.valueOf(i)).start();
        }
    }
}

题外话:

hashSet底层是什么?

public HashSet() { map = new HashMap<>(); }

add set本质就是map key是无法重复的!

public boolean add(E e) {  return map.put(e, PRESENT)==null; }
private static final Object PRESENT = new Object();//PRESENT是不变的值

6.3 Map ConcurrentHashMap

底层代码:
默认初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 写成了位运算

最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;

默认的加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

Map map = new HashMap<>();
默认等价于》 new HashMap<>(16,0.75);

解决方法:
1.Map map = Collections.synchronizedMap(new HashMap<>());
2.Map map = new ConcurrentHashMap<>();
代码:

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class MapList {
    public static void main(String[] args) {
        Map<String, Object> map = new ConcurrentHashMap<>();
        for (int i = 0; i < 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));//生成随机字符串
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

7.Callable

7.1 与Runnable的区别

1.可以有返回值
2.可以抛出异常
3.方法不同,run()/call()
4. Runnable效率比Callable相对较低,用Callable更多

7.2 Callable怎么启动

Thread的实现接口是Runnable,所以只能接收它
Runnable有个实现类FutureTask,它就和Callable有关系。
FutureTask里面有个构造方法,里面的参数是Callable
最终:Callable通过FutureTask,可以调用Thread

Callable是无法直接启动的,那么怎么启动呢?
new Thread(new Runnable()).start();
等价于 new Thread(new FutureTask()).start();
所以new Thread(new FutureTask(Callable)).start();

7.3 代码

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //怎么启动Callable
        MyThread thread = new MyThread();
        FutureTask<Integer> futureTask = new FutureTask<>(thread);//适配类
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();
        //结果会被缓存,效率高 有两个线程但结果只有一个
        Integer o = futureTask.get();//获取Callable的返回结果
        //上面的get方法需要等待结果返回 如果下面的方法是个耗时的操作,
        //那么就可能会产生阻塞,所以最好写在最后,或者使用异步通信来处理
        System.out.println(o);
    }
}
class MyThread implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("call()");
        return 1024;
    }
}

结果:
call()
1024

注意点:
1.有缓存
2.结果可能需要等待,会阻塞。

你可能感兴趣的:(java,intellij-idea,juc)