找往期文章包括但不限于本期文章中不懂的知识点:
个人主页:我要学编程程(ಥ_ಥ)-CSDN博客
所属专栏:JavaEE
目录
Callable接口
ReentrantLock
synchronized 与 ReentrantLock的区别
信号量(Semaphore)
CountDownLatch
多线程下使用ArrayList、哈希表
JUC 是值 java.util.current 包,现在我们要学习这些包中的一些常用的类。
Callable接口
Callable 接口与Runnable接口一样,都是用来包装任务的,只不过Callable接口有泛型参数且其方法有返回值,我们下面就来演示Callable接口的使用。
代码演示:
public class Test {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception { // 这里面是任务与run方法类似
for (int i = 0; i < 10000; i++) {
count++;
}
return count;
}
};
// 将任务进一步分装起来
FutureTask<Integer> task = new FutureTask<>(callable);
// 再将任务给到Thread
Thread t = new Thread(task);
t.start();
t.join();
System.out.println("count: "+ count);
}
}
下面是lambda表达式的写法:
public class Test {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
// 使用lambda表达式代替匿名内部类
FutureTask<Integer> task = new FutureTask<>(()->{
for (int i = 0; i < 10000; i++) {
count++;
}
return count;
});
Thread t = new Thread(task);
t.start();
t.join();
System.out.println("count: "+count);
}
}
上面是我们手动使 main线程阻塞等待 t线程执行完毕,我们还可以使用 FutureTask 中的get方法,从而去被动阻塞 main线程。
public class Test {
private static Object locker = new Object();
public static void main(String[] args) throws InterruptedException, ExecutionException {
FutureTask<Integer> task = new FutureTask<>(()->{
int sum = 0;
for (int i = 1; i <= 1000; i++) {
sum += i;
}
return sum;
});
Thread t = new Thread(task);
t.start();
// 在调用get方法时,得到的是call方法的返回值,即主线程会阻塞等待t线程执行完call方法
System.out.println(task.get());
}
}
总结:Callable 接口也是函数式接口,通过 call 方法来完成任务,最终的任务需要被 FutureTask进一步分装,从而给到Thread。
ReentrantLock
ReentrantLock是可重入互斥锁,和 synchronized 定位类似,都是用来实现互斥效果,保证线程安全。但是ReentrantLock 是Java标准库提供的一个类,而不是关键字。
ReentrantLock 有三种方法:
1、lock():加锁,如果获取不到锁就会一直等待,也就是死等。
2、tryLock(超时时间,时间级别):加锁,如果在超时时间之内没有获取到锁,也是一直等待,但如果超出了超时时间的话,就会放弃等待。
3、unlock():解锁。
代码演示:
1、lock—unlock方法的使用:
public class Test {
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
ReentrantLock reentrantLock = new ReentrantLock();
Thread t1 = new Thread(()->{
for (int i = 0; i < 100000; i++) {
reentrantLock.lock();
count++;
reentrantLock.unlock();
}
});
Thread t2 = new Thread(()->{
for (int i = 0; i < 100000; i++) {
reentrantLock.lock();
count++;
reentrantLock.unlock();
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("count: "+count);
}
}
2、tryLock方法的使用:
public class Test {
public static void main(String[] args) throws InterruptedException {
ReentrantLock reentranLock = new ReentrantLock();
Thread t = new Thread(()->{
try {
reentranLock.lock();
System.out.println("t线程开始");
Thread.sleep(3000);
System.out.println("t线程结束");
reentranLock.unlock();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
t.start();
Thread.sleep(1000); // 确保t线程先加锁成功
// 等待1s之后,就会不等了
boolean state = reentranLock.tryLock(1000, TimeUnit.MILLISECONDS);
if (state) {
System.out.println("main线程成功获取锁");
reentranLock.unlock();
} else {
System.out.println("main线程获取锁失败");
}
System.out.println("main线程结束");
}
}
运行结果:
tryLock还有一个重载的方法,是不带有任何参数的,其含义是:尝试去获取锁时,如果锁处于空闲状态就返回true,否则就返回false。这个是不会去等待的。
synchronized 与 ReentrantLock的区别
1、synchronized 是关键字,其底层的实现是JVM内部通过C++实现的,而 ReentrantLock 是标准库中的类,是用Java实现的。
2、synchronized 是通过代码块来控制加锁与解锁的,而 ReentrantLock是通过lock 与 unlock 方法来控制加锁与解锁的,且一定要记得及时去解锁。
3、ReentrantLock 除了普通的加锁、解锁操作之外,还提供了 tryLock方法。不带参数的版本,就是直接去判断这个锁的状态,如果没有线程持有的话,就会进行加锁操作,然后返回true;反之,则会直接返回false,不会进行等待。而带有参数的版本就会等待对应的超时时间去尝试获取锁,如果在超时时间之外了,就会直接返回false。
4、ReentrantLock 本身默认是非公平锁,但是其提供了 公平锁的实现方式。
5、ReentrantLock搭配的等待通知机制,是Condition类,相比wait notify来说功能更强大一些,但是使用的方法是类似的。也是需要先加锁,然后再进行使用的。await 方法是可以更精准地唤醒等待的线程。在有多个等待线程的情况下,signal 可以选择唤醒特定的线程,而Object 类的notify方法在唤醒线程时是相对随机的。
代码演示:
public class Test {
public static void main(String[] args) throws InterruptedException {
// 下面的锁就是公平锁,是在参数内部传入一个true即可
ReentrantLock reentrantLock = new ReentrantLock(true);
Condition condition = reentrantLock.newCondition();
Thread t1 = new Thread(()->{
System.out.println("t线程开始执行");
reentrantLock.lock();
try {
System.out.println("t1线程即将被阻塞");
condition.await(); // 阻塞线程t1
System.out.println("t1线程被唤醒");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
reentrantLock.unlock();
System.out.println("t线程结束执行");
});
t1.start();
Thread.sleep(1000); // 确保t1线程先加锁成功
Thread t2 = new Thread(()->{
System.out.println("t2线程开始执行");
reentrantLock.lock();
condition.signal(); // 唤醒正在处于阻塞状态的线程
reentrantLock.unlock();
System.out.println("t2线程结束执行");
});
t2.start();
System.out.println("main线程结束");
}
}
信号量(Semaphore)
信号量主要用来协调进程与线程之间的资源分配。其底层是一个计数器,记录当前资源的可用个数。申请资源,对应的P操作,信号量会减少,释放资源,对应的V操作,信号量会增加。当信号量对应的计数器为0了,此时线程再去申请资源的话,就会线程阻塞。
在Java标准库中,Semaphore 是对应的类。
代码演示:
public class Test {
public static void main(String[] args) throws InterruptedException {
// 通过参数指定“可用资源”的个数
Semaphore semaphore = new Semaphore(5);
System.out.println("可用资源的个数:"+semaphore.availablePermits());
// 获取资源
for (int i = 0; i < 3; i++) {
System.out.println("正在获取可用资源~");
// 获取"可用资源"
semaphore.acquire(); // 也可以传入参数来设定获取的个数,默认1
}
System.out.println("剩余可用资源的个数:"+semaphore.availablePermits());
// 释放资源
for (int i = 0; i < 3; i++) {
System.out.println("正在释放可用资源~");
// 释放“可用资源”
semaphore.release(); // 也可以传入参数来设定释放的个数,默认1
}
System.out.println("最终可用资源的个数:"+semaphore.availablePermits());
}
}
运行结果:
注意:当信号量的初始容量为1时,此时就相当于是一把锁。
CountDownLatch
当一个大的任务被分成多个小任务时,如何知道所有的小任务全部执行完了呢?
1、可以使用 join 的普通等待方法。
2、可以使用计数器来记录当前的完成任务的线程数。
而针对第二种方式,Java标准库中给出了一个类:CountDownLatch。通过构造方法创建出多个任务,当与之对应的线程完成一个任务时,就可以调用 countDown方法来更新计数器的值,最终当计数器的值达到我们的预期时,便可以让主线程继续去执行其它的逻辑了。
代码实现:
public class Test {
public static void main(String[] args) throws InterruptedException {
int n = 3;
CountDownLatch latch = new CountDownLatch(n); // 创建了初始值为n的计数器
// 模拟下载的线程
System.out.println("等待下载...");
for (int i = 0; i < n; i++) {
new Thread(() -> {
System.out.println("正在下载...");
try {
// 模拟下载过程
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("下载完成...");
latch.countDown(); // 更新计数器,计数器--
}).start();
}
// 等待上述任务全部执行完毕,当计数器为0时,任务执行完毕,脱离阻塞。
// 任务没有执行完成时,主线程会处于阻塞状态
latch.await();
System.out.println("下载完成,正在解压...");
System.out.println("成功解压...");
}
}
多线程下使用ArrayList、哈希表
普通的ArrayList是没有加锁的,那么在多线程的情境下使用,就会出现线程安全问题,而解决线程安全问题,有三种方法:
1、根据需要自行加锁。
2、无脑将所有的可能会出现线程安全问题的代码全部进行加锁。
3、CopyOnWriteArrayList。
第一二种方式都是采用加锁操作,来确保线程安全。
代码演示:
public class Test {
private static final Object locker = new Object();
public static void main(String[] args) throws InterruptedException {
ArrayList<Integer> arrayList = new ArrayList<>();
Thread t1 = new Thread(()->{
for (int i = 0; i < 100000; i++) {
synchronized (locker) {
arrayList.add(i);
}
}
});
Thread t2 = new Thread(()->{
for (int i = 0; i < 100000; i++) {
synchronized (locker) {
arrayList.add(i);
}
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(arrayList.size());
}
}
上面这种方式就是按需加锁,只在出现线程安全问题的代码部分进行加锁操作,而不是对add这个方法进行无脑的加锁。
第三种方式,采用了写时拷贝的方法。当线程1在进行"写"操作时,如果线程2来进行"读"操作,这时就让线程2读取原来版本的数据,这样线程1在进行"写"操作时,就不会影响到线程2的"读"操作,也就不会造成线程不安全,那么也就没必要进行加锁操作,从而导致的程序运行效率降低。
缺陷:
1、当数据量过大时,拷贝的成本也就高了很多,这样最终的效率可能还不如加锁的操作呢。
2、当多个线程进行修改操作时,就不能保证线程安全了。因为多个线程进行修改操作,就会拷贝出多份数据,最后怎么合并呢?可能会出现覆盖的问题,其次这是并发执行,因此没发确定顺序的先后,因此就导致了最终数据的不确定性。
普通的哈希表也是有线程安全问题的。Java标准库中,给我们提供了两个类:Hashtable、ConcurrentHashMap。前者是对整个哈希表进行加锁操作,而后者是对哈希表的每个元素进行加锁操作。
不管是Java标准库中的哈希表,还是我们之前手动实现的哈希表,针对哈希冲突的问题,我们采用的都是数组+链表的方式,而不是去使用线性探测。而对于数组+链表这种方式,只有在同一个链表上面进行修改操作时,才会涉及线程安全问题,因此没必要对整个数组进行加锁。
ConcurrentHashMap相对于Hashtable有以下三个优化的地方:
1、针对数组的加锁操作,变成了对链表进行加锁操作;
2、使用原子类对size进行维护;
3、对于哈希扩容的问题,是分多次进行的,这样每一次所消耗的时间就会比较少。例如,准备扩容时,就可以标记一下,等到下一次在进行put操作时,重新将这个元素所在原链表进行新的哈希映射,当每一个链表都修改完毕时,哈希表的扩容操作也就完成了。
好啦!本期 初始JavaEE篇——多线程(8):JUC的组件 的学习之旅就到此结束啦!我们下一期再一起学习吧!