目录
一、Callable接口
1、创建线程的操作
2、编写多线程代码
(1)实现Runnable接口(使用匿名内部类)
(2)实现Callable接口(使用匿名内部类)
二、ReentrantLock
1、ReentrantLock和synchronized的区别
2、如何选择使用哪个锁?
三、原子类
四、线程池
五、信号量 Semaphore
代码示例
六、CountDownLatch
代码示例
七、相关面试题
1、线程同步的方式有哪些?
2、为什么有了synchronized还需要juc下的lock?
3、AtomicInteger的实现原理是什么?
4、信号量听说过么?之前都用在过哪些场景下?
5、解释⼀下ThreadPoolExecutor构造方法的参数的含义
JUC即java.utill.concurrent,里面放了一些多线程编程时有用的类,下面是里面的一些类。
一、Callable接口
1、创建线程的操作
多线程编程时,创建线程有以下五种操作:
1、继承Thread类(包含了匿名内部类的方式)
2、实现Runnable接口(包含了匿名内部类的方式)
3、基于lambda表达式
4、基于Callable接口
5、基于线程池
为什么有那么多方式可以创建线程,前面三个创建线程很方便,也经常用,为啥还要学Callable接口创建线程的方式呢?答案是因为有它独特的优势和特性。
以下是Callable和Runnable的区别:
Runnable关注的是这个的过程,也就是重新run方法里面的内容,它的返回值是void。
Callable即关注过程,也关注结果,Callable提供call方法,返回值就是执行任务得到的结果。
2、编写多线程代码
创建一个线程,这个线程完成1+2+3+...+1000的任务,并打印出结果。
(1)实现Runnable接口(使用匿名内部类)
代码如下:
public class ThreadDemo1 {
private static int sum = 0;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(new Runnable() {
int result = 0;
@Override
public void run() {
for (int i = 1; i <= 1000; i++) {
result += i;
}
sum = result;
}
});
t.start();
t.join();
System.out.println("sum = " + sum);
}
}
执行结果:
可以看到,用实现Runnable接口的代码可以完成任务,但并不优雅,因为要创建一个全局的静态变量,如果其他场景下使用Runnable接口,需要创建很多这样的变量,就容易混淆、记错这些变量的代指。
(2)实现Callable接口(使用匿名内部类)
代码如下:
public class ThreadDemo2 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 1; i <= 1000; i++) {
sum += i;
}
return sum;
}
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread t = new Thread(futureTask);
t.start();
int result = futureTask.get();
System.out.println("result = " + result);
}
}
执行结果如下:
和预期值一样。
实现Callable接口,没有创建变量也可以完成任务,通过call方法的返回值,输出我们想要的值。
注意:
1、这里的FutureTask,因为Thread里面的构造方法的参数没有Callable接口,但有FutureTask类,所以成为了Thread和Callable的粘合剂。
2、FutureTask直接翻译的意思是:未来的任务,那么未来的任务肯定没有执行完,最终取结果的时候就需要一个凭据,而futureTask就是凭据;就像我们吃麻辣烫的时候,付完款拿到的小牌子,当前工作人员没做完麻辣烫,需要做完后叫到我们的号才能取餐。
3、FutureTask的get方法有阻塞功能,如果线程没有执行完,get就会阻塞,等线程执行完了,return了结果,才会执行get方法返回值。
Callable是一个“锦上添花”的东西,Callable能干的事,Runnable也能干,但对于这种带返回值的任务,使用Callable会更好,代码更直观、简单,但需要理解这里FutureTask起到的作用。
二、ReentrantLock
ReentrantLock是可重入互斥锁,跟synchronized定位类似,都是实现互斥的效果,保证线程安全。在java的远古时期,sychronized锁的功能没有那么强大,没有各种优化,ReentrantLock就是可以用来使用可重入锁的(历史遗留)。
传统的锁的风格,锁对象提供两个方法:lock和unlock,这个写法就容易忘记解锁unlock,或者在unlock之前,提前return了,可能引起unlock没执行到,所以正确使用ReentrantLock锁,unlock操作要放进finally。
1、ReentrantLock和synchronized的区别
那么有了synchronized,为啥还要有ReentrantLock呢?有以下三点(也是synchronized与ReentrantLock的区别):
1、ReentrantLock提供了tryLock操作。synchronized锁直接进行加锁,加锁不成功就会阻塞;ReentrantLock锁进行加锁时,进行加锁时,如果加锁不成功,不会阻塞,直接返回false,这里的tryLock的操作空间更大。
2、ReentrantLock锁是公平锁。synchronized锁是非公平锁。
3,、ReentrantLock和synchronized搭配的等待机制不同。synchronized锁搭配的是wait、notify,而ReentrantLock锁搭配的是Condition类,功能比wait、notify略强一点。
2、如何选择使用哪个锁?
(1)当锁竞争不激烈时,使用synchronized锁,效率更高,自动释放更方便。
(2)锁竞争激烈时,使用ReentrantLock,搭配tryLock更加灵活控制加锁行为,而不是死等
(3)如果要使用公平锁,就使用ReentrantLock。
三、原子类
原⼦类内部⽤的是CAS实现,所以性能要比加锁实现i++高很多。原⼦类有以下几个
• AtomicBoolean
• AtomicInteger
• AtomicIntegerArray
• AtomicLong
• AtomicReference
• AtomicStampedReference
以AtomicInteger举例,常见方法有
addAndGet(int delta); i += delta
decrementAndGet(); --i
getAndDecrement(); i--
incrementAndGet(); ++i
getAndIncrement(); i++
CAS的详细介绍地址:多线程(进阶二:CAS)-CSDN博客
四、线程池
详细介绍地址:多线程(初阶九:线程池)-CSDN博客
五、信号量 Semaphore
信号量,用来表示“可用资源的个数”,本质还是一个计数器。而信号量可以理解成停车场的展示牌:当前有100个停车位,相当于有100个可用资源。
1、当有车开进去的时候,就相当于申请一个可用资源,可用车位就-1(这个称为信号量的P操作)。
2、当有车开出去的时候,就相当于释放一个可用资源,可用车位就+1(这个称为信号量的V操作)。
3、当停车场停满车的时候,也就是计数器值为0了,如果还尝试申请资源,就会阻塞等待,知道有其他线程释放资源。
注意:所谓的锁,本质也是信号量,这个信号量比较特殊,可以理解成计数器值为1的信号量。
锁处于释放状态,计数器值就是1;锁处于加锁状态,计数器值就是0。对于这种非0即1的信号量,称为 “二元信号量”。
代码示例
用两个线程一起完成count自增10000次操作。
public class ThreadDemo1 {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
Semaphore semaphore = new Semaphore(1);
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
try {
semaphore.acquire();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
count++;
semaphore.release();;
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
try {
semaphore.acquire();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
count++;
semaphore.release();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("count = " + count);
}
}
执行结果:
注意:信号量也可以保证线程安全。保证线程安全有以下几种方式:
1、使用synchronized锁
2、使用ReentrantLock锁
3、CAS原子类操作
4、使用信号量Semaphore
六、CountDownLatch
CountDownLatch是针对特定场景的小工具。例如:多线程执行任务,把一个大的任务拆分成一个个的小任务,由每个线程执行这些小任务,等执行完全部的小任务,再进行一个汇总,从而完成这样的大任务。那么我们是怎么知道啥时候所有的小任务都完成了呢?如果使用join是无法感知到的,这时候就可以使用CountDownLatch这样的小工具了,它能感知到所有的小任务都完成。
有这样的多线程下载软件,像idm,基本可以下载任何网站的电影,如果使用浏览器默认的下载方式没有那么快,但idm不一样,因为是多线程下载,可以下载的很快,最终完成后把所有的内容都拼接在一起,就是使用CountDownLatch这样的小工具,可以感知到啥时候这些小任务都下载完了。
代码示例
创建出5个线程下载一个任务,把这个任务分成5个小任务,5个线程进行下载,都下载往后,打印下载完成。
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
//1、此处的构造方法写10,意思是有10个线程/任务
CountDownLatch latch = new CountDownLatch(5);
for (int i = 0; i < 5; i++) {
int id = i;
Thread t = new Thread(() -> {
Random random = new Random();
//[0,5)
int time = (random.nextInt(5) + 1) * 1000;
System.out.println("线程" + id + "开始下载");
try {
Thread.sleep(time);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("线程" + id + "结束下载");
//2、告知CountDownLatch我执行完了
latch.countDown();
});
t.start();
}
//3、通过这个await操作来等待所有任务结束,也就是countDown被调用10次了
latch.await();
System.out.println("所有任务都下载完成!");
}
}
执行结果:
注意:
1、构造CountDownLatch实例,初始化5表⽰有5个任务需要完成.
2、每个任务执行完毕,都调用 latch.countDown() .在CountDownLatch内部的计数器同时自
减.
3、主线程中使用 latch.await(); 阻塞等待所有任务执行完毕.相当于计数器为0了.
七、相关面试题
1、线程同步的方式有哪些?
答:synchronized、ReentrantLock、Semaphore、原子类的一些操作等都可以。
2、为什么有了synchronized还需要juc下的lock?
答:以JUC的ReentrantLock为例。
(1)ReentrantLock提供了tryLock操作,进行加锁时,如果失败则返回false,不会阻塞,搭配使用tryLock使用更灵活,而不是死等。而synchronized加锁失败会阻塞,可能会死等。
(2)ReentrantLock和synchronized搭配的wait、notify机制不同,ReentrantLock搭配的是Condition类,功能比wait、notify更强,可以精确的控制唤醒某个线程。
(3)synchronized是非公平锁,ReentrantLock是公平锁。
3、AtomicInteger的实现原理是什么?
基于CAS机制,伪代码如下:
详细过程参考地址:多线程(进阶二:CAS)-CSDN博客
4、信号量听说过么?之前都用在过哪些场景下?
答:信号量,用来表示“可用资源的个数”,本质上是个计数器,停车场的展示牌原理就是使用了信号量。使用过的场景:两个线程完成count变量自增10000次;创建Semaphore实例的时候,构造方法的实参传1,表示计数器值为1,当一个线程自增钱就会申请1个资源——P操作,自增完后就会释放1个资源——V操作;两个线程不会同时自增,不会出现线程安全问题,自增前P操作的计数器-1,计数器值为0,另一个线程不会自增,等当前线程自增完后,V操作,计数器值+1,才能进行自增。可以解决线程安全问题。文章来源:https://www.toymoban.com/news/detail-828345.html
5、解释⼀下ThreadPoolExecutor构造方法的参数的含义
参考下面地址内容:多线程(初阶九:线程池)-CSDN博客文章来源地址https://www.toymoban.com/news/detail-828345.html
都看到这了,点个赞再走吧,谢谢谢谢!
到了这里,关于多线程(进阶三:JUC)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!