Java多线程学习（六）
1.获取多线程的第三种方式
之前的学习总结中，提到了两种多线程的获取方式，一是继承Thread类，二是实现Runnable接口。
今天来学习第三种方式——实现Callable接口
class Test1 implements Callable<Integer>{ @Override public Integer call() throws Exception { return null; } } class Test2 implements Runnable{ @Override public void run() { } }
显然，Test1类实现了Callable接口，Test2类实现了Runnable接口，两者有何区别？面试常问的。区别是：
Callable接口的实现方法具有返回值
Callable接口的实现方法会抛出异常
Callable接口的实现方法是call()方法，Runnable接口的实现方法是run()方法
启动一个实现Callable接口的线程的方法，这会抛出ExecutionException, InterruptedException异常
public class CallableTest { public static void main(String[] args) throws ExecutionException, InterruptedException { FutureTask<Integer> futureTask = new FutureTask<>(new Test1()); new Thread(futureTask,"A").start(); System.out.println(futureTask.get()); } }
使用FutureTask类来启动线程有一该好处，如果Callable线程中的操作复杂耗时较长，程序可以执行其他的线程操作，再等待Callable线程返回处理的结果，这样就减少了线程阻塞的时间。
案例如下：
public class CallableTest { public static void main(String[] args) throws ExecutionException, InterruptedException { FutureTask<Integer> futureTask = new FutureTask<>(new Test1()); new Thread(futureTask,"A").start(); new Thread(futureTask,"B").start(); System.out.println(Thread.currentThread().getName()+"线程到了这里");//先执行主线程的其他操作 System.out.println(futureTask.get());//后获取Callable线程返回的处理结果，减少了等待时间 } } class Test1 implements Callable<Integer>{ @Override public Integer call() throws Exception { System.out.println("Callable线程到了这里"); Thread.sleep(4000); return 1234; } }
另外，如果有两个线程由FutrueTask进行处理，call()方法只能被执行一次，这是一种复用的思想。
2.线程阻塞案例——CountDownLatch
public class CountDownLatchDemo { public static void main(String[] args) { for (int i = 1; i <=6 ; i++) { new Thread(()->{ System.out.println(Thread.currentThread().getName()+"离开教室"); },i+"").start(); } System.out.println(Thread.currentThread().getName()+"关门走人"); } }
以上代码的运行结果是这样的
需求是：所有离开教室线程执行完成后，才能执行关门走人的线程，需要借助 java.util.concurrent.CountDownLatch来实现这个需求
package com.Zhongger.Day07; import java.util.concurrent.CountDownLatch; /** * @Author Zhongger * @Description * @Date 2020.3.2 */ public class CountDownLatchDemo { public static void main(String[] args) throws InterruptedException { CountDownLatch countDownLatch = new CountDownLatch(6); for (int i = 1; i <=6 ; i++) { new Thread(()->{ System.out.println(Thread.currentThread().getName()+"离开教室"); countDownLatch.countDown(); },i+"").start(); } countDownLatch.await(); System.out.println(Thread.currentThread().getName()+"关门走人"); } }
其原理是这样的：
3. CyclicBarrier
案例是，收集完七颗龙珠才能召唤神龙
package com.Zhongger.Day07; import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; /** * @Author Zhongger * @Description * @Date */ public class CyclicBarrierDemo { public static void main(String[] args) { CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> { System.out.println("召唤神龙"); }); for (int i = 1; i <= 7; i++) { final int tempInt=i; new Thread(()->{ System.out.println(Thread.currentThread().getName() + "\t收集到第:" + tempInt + "颗龙珠"); try { cyclicBarrier.await(); } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } },i+"").start(); } } }
4.Semaphore
抢红包案例
package com.Zhongger.Day07; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; /** * @Author Zhongger * @Description * @Date */ public class SemaphoreDemo { public static void main(String[] args) { Semaphore semaphore = new Semaphore(3);//模拟资源类，有3个空车位 for (int i = 1; i <= 6 ; i++) { new Thread(()->{//哪个线程先抢到了车位，就需要把车位数减1 try { semaphore.acquire(); System.out.println(Thread.currentThread().getName() + "\t抢占了车位"); TimeUnit.SECONDS.sleep(3);//一旦一个线程抢到了资源，就占用三秒钟 System.out.println(Thread.currentThread().getName() + "\t离开了车位"); } catch (InterruptedException e) { e.printStackTrace(); } finally { semaphore.release(); } },i+"").start(); } } }
运行结果如下：
原理是：
如果 Semaphore semaphore = new Semaphore(1)，就相当于synchornized
5.ReadWriteLock
先来看看写入数据时不加写锁时的情况
package com.Zhongger.Day07; import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; /** * @Author Zhongger * @Description * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行 * 但是 * 如果一个线程想去写共享资源，就不应该再有其他线程对该资源进行读或写 * 总结： * 读-读共存 * 读-写不能共存 * 写-写不能共存 * * @Date 2020.3.2 */ public class ReadWriteLockDemo { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 1; i <=5 ; i++) { final int tempInt=i; new Thread(()->{ myCache.put(tempInt+"",tempInt); },i+"").start(); } for (int i = 1; i <=5 ; i++) { final int tempInt=i; new Thread(()->{ myCache.get(tempInt+""); },i+"").start(); } } } class MyCache{ private volatile Map<String,Object> map=new HashMap<>(); public void put(String key,Object value){ System.out.println(Thread.currentThread().getName()+"\t写入数据"+key); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } map.put(key, value); System.out.println(Thread.currentThread().getName()+"\t写入完成"); } public void get(String key){ System.out.println(Thread.currentThread().getName()+"\t读取数据"); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } Object result = map.get(key); System.out.println(Thread.currentThread().getName()+"\t读取数据完成"+result); } }
运行结果时这样的，当一个线程在写，还没有写完的时候，有其他的线程来写数据了，这就不能保证一致性。
现在，需要对读和写操作来加锁保护。
package com.Zhongger.Day07; import java.util.HashMap; import java.util.Map; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * @Author Zhongger * @Description * 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行 * 但是 * 如果一个线程想去写共享资源，就不应该再有其他线程对该资源进行读或写 * 总结： * 读-读共存 * 读-写不能共存 * 写-写不能共存 * * @Date 2020.3.2 */ public class ReadWriteLockDemo { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 1; i <=5 ; i++) { final int tempInt=i; new Thread(()->{ myCache.put(tempInt+"",tempInt); },i+"").start(); } for (int i = 1; i <=5 ; i++) { final int tempInt=i; new Thread(()->{ myCache.get(tempInt+""); },i+"").start(); } } } class MyCache{ private volatile Map<String,Object> map=new HashMap<>(); private ReadWriteLock readWriteLock=new ReentrantReadWriteLock(); public void put(String key,Object value){ readWriteLock.writeLock().lock(); System.out.println(Thread.currentThread().getName()+"\t写入数据"+key); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } map.put(key, value); System.out.println(Thread.currentThread().getName()+"\t写入完成"); readWriteLock.writeLock().unlock(); } public void get(String key){ readWriteLock.readLock().lock(); System.out.println(Thread.currentThread().getName()+"\t读取数据"); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } Object result = map.get(key); System.out.println(Thread.currentThread().getName()+"\t读取数据完成"+result); readWriteLock.readLock().unlock(); } }
这样，写的操作就能够保证一致性了。
6.BlockingQueue阻塞队列
当队列是空的，从队列中获取元素的操作会被阻塞
当队列是满的，从队列中添加元素的操作会被阻塞
BlockingQueue是一个接口，其实现类有以下几种：
