JUC详解（一）

已于 2022-02-03 17:16:57 修改
阅读量659 收藏 2
点赞数 1
文章标签： java intellij-idea juc
于 2022-01-17 19:42:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51945098/article/details/122529922
版权

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

JUC（一）

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<string> list = new Vector<>(); vector默认就是安全的，里面有Synchronized
但这个太老了，一般不用
2.List<string> list = collections.synchronizedList(new ArrayList<>())；(工具类)
用工具类让它变得安全
3.List<String> 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 转换成字符串
        }
    }
}

结果：（随机）
在这里插入图片描述

6.2 Set CopyOnWriteArraySet

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

解决方法：
1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
2. Set<String> 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<String, String> map = new HashMap<>();
默认等价于》 new HashMap<>(16,0.75);

解决方法：
1.Map<String, Object> map = Collections.synchronizedMap(new HashMap<>());
2.Map<String, Object> 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<V>()).start();
所以new Thread(new FutureTask<V>(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的xz
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JUC详解（各种乱七八糟的锁）
qdyones的博客
02-19 2471
JUC 进程和线程： 进程：一个进程可以包含多个线程，至少是一个线程，java默认2个线程——main、GC（垃圾回收） 线程：开了一个软件，写字的时候也会有自动保存的线程在进行，Thread、Runnable、Callable java开启不了线程，java操作的是底层的C++，java无法操作，用的是虚拟机 并发与并行： 并发：多线程操作同一个资源（假设cpu只有一核的时候，模拟多线程，快速交替处理线程） 并行：CPU多核情况下才有，多个线程同时执行 并发编程的本质：充分利用电脑的CPU 线程有几种
JDK中多线程之JUC集合的JDK源码解读配合大神的一起看，秒懂。
MRA__S__的专栏
03-02 2129
一、    “JUC集合”01之框架 1)  概要 之前，在"Java 集合系列目录(Category)"中，讲解了Java集合包中的各个类。接下来，将展开对JUC包中的集合进行学习。在学习之前，先温习一下"Java集合包"。本章内容包括： Java集合包 JUC中的集合类 2)  Java集合包 在“Java 集合系列01之 总体框架”中，介绍java集合的架构。主体内容包括Coll...
JUC基础知识(个人总结)
hellosrc的博客
03-04 8692
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
Java JUC详解：深入理解并发编程工具包
最新发布
suqieer的博客
04-24 1456
java.util.concurrent：核心并发工具类，如ExecutorService、Semaphore、CountDownLatch等。java.util.concurrent.atomic：原子变量类，如AtomicInteger、AtomicLong、AtomicReference等。java.util.concurrent.locks：锁和同步器类，如ReentrantLock、ReadWriteLock、Condition等。
java juc_JUC
weixin_39934085的博客
02-12 151
前言：在Java中，线程部分是一个重点，本篇文章说的JUC也是关于线程的。JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，JDK 1.5开始出现的。下面一起来看看它怎么使用。欢迎大家关注我的公众号 javawebkf，目前正在慢慢地将简书文章搬到公众号，以后简书和公众号文章将同步更新，且简书上的付费文章在公众号上将免费。一、volatile关键字与内存可...
【JUC】JUC的一些基础概念
qq_42023953的博客
11-29 119
介绍JUC相关的基础概念，并举例说明了一些易混淆的概念
juc详解juc详解juc详解juc详解juc详解juc详解juc详解
08-02
juc详解juc详解juc详解juc详解juc详解
06、JUC并发工具类在大厂的应用场景详解-ev
03-07
06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev06、JUC并发工具类在大厂的应用场景详解_ev...
JUC(一)-AQS源码分析
01-21
AQS源码分析一、锁的介绍1.1 乐观锁/悲观锁1.2 共享锁/独占锁1.3 公平锁/非公平锁1.4 小结二、AQS框架结构介绍2.1 类图2.2 AQS数据结构三、源码详解3.1 acquire源码详解3.2 release源码详解四、从ReentranLock看公平...
java并发编程专题（十）----(JUC原子类)基本类型详解
08-18
Java并发编程专题（十）----(JUC原子类)基本类型详解 本资源主要介绍了Java JUC原子类基本类型的相关知识点，包括AtomicInteger、AtomicLong、AtomicBoolean等基本类型的使用方法和原理。通过对原子操作和 일반操作...
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
主要介绍了java（JUC）ReentrantLock的的相关资料，文中讲解非常详细，实例代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Java JUC包 思维导图总结1
03-25
自己学习过程对Java JUC包知识的总结，看完并理解基本能应付各种基本的问题点，墙裂推荐分享 博客跳转链接： https://blog.csdn.net/qq_35642036/article/details/82767070
Java JUC并发编程详解
靖节先生的博客
12-20 541
Java JUC并发编程详解1. JUC概述1.1 JUC简介1.2 进程与线程1.2 并发与并行1.3 用户线程和守护线程2. Lock接口2.1 Synchronized2.2 什么是 Lock2.3 ReentrantLock2.4 ReadWriteLock2.5 Lock与Synchronized区别3. 线程间通信3.1 synchronized方案3.2 lock方案3.4 线程间定制化通信4. 集合线程安全4.1 ArrayList线程不安全4.2 Vector线程安全4.3 Collect
JUC并发编程
paiidds的博客
08-10 516
JUC并发学习
了解什么是JUC
qq_16733389的博客
03-27 678
JUC指的是包下的所有提供的工具类的简称。这是一个处理线程的工具包，JDK1.5开始出现的。进程（Process）：指的是计算机中的程序关于某数据集合上的一次运行活动。是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。程序是指令、数据及组织形式的描述，进程是程序的实体。线程（Thread）
JUC并发编程（java.util .concurrent工具包）详解与实例演示
BaiKnow的博客
02-03 1533
JUC 并发编程 作者：pox21s 概述 在Java中，线程部分是一个重点，本篇文章说的是关于线程并发编程。JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，从JDK 1.5开始出现。 1.基本概念 1.1 进程和线程 1.1.1 定义 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个基本单位。 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥
Java多线程详解（JUC并发编程）
极客
10-10 993
文章目录一、Condition二、CountDownLatch（减法计数器）三、CyclicBarrier(加法计数器)四、Semaphore(限流)五、ReadWriteLock（读写锁）六、BlockingQueue（队列）四组API七、SynchronousQueue（同步队列）八、线程池（4大方法，7大参数，4大拒绝策略）8.1 四大方法（==不安全，需要手动创建线程池==）8.2 七大参数：==ThreadPoolExecutor==8.3 ThreadPoolExecutor和ForkJoinP
JUC底层的详细学习(狂神JUC笔记)(全网最全)---什么是JUC
weixin_43886282的博客
01-29 686
什么是JUC java.util 是Java的一个工具包 业务：普通的线程代码 Thread Runnable： 没有返回值、效率相比于Callable 相对较低！ 线程和进程 提问？JAVA真的可以开启线程吗？ 开不了的！ public synchronized void start() { /** * This method is not invoked for the main method thread or "system" * gr
JUC总结详细笔记
最初的模样
01-26 1096
1、juc是什么 java.util.concurrent在并发编程中使用的工具类 2、进程和线程 （1）进程/线程是什么 进程：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。 线程：通常在一个进程中可以包含至少一个线程。线程可以利用进程所拥有的资源，在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥
juc-1(2).docx
03-29
在Java世界中，Java Util Concurrency (JUC) 是一个至关重要的工具包，它包含了多种高效处理并发问题的类和接口。JUC是`java.util.concurrent`包的简称，主要用于管理和控制多线程环境中的线程行为，提供同步、异步...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值