Java多线程学习（六）

约定不等于承诺〃 2023-07-10 11:17 121阅读 0赞

## Java多线程学习（六） ##

2020.3.2学习总结

#### 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异常

使用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()方法只能被执行一次，这是一种复用的思想。  
![在这里插入图片描述][20200302093308478.png]

#### 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()+"关门走人");
        }
    }

以上代码的运行结果是这样的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70]  
需求是：所有离开教室线程执行完成后，才能执行关门走人的线程，需要借助 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()+"关门走人");
        }
    }

其原理是这样的：  
![在这里插入图片描述][20200302101429525.png]

#### 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();
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 1]

#### 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();
            }
        }
    }

运行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 2]  
原理是：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 3]  
如果 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);
        }
    
    }

运行结果时这样的，当一个线程在写，还没有写完的时候，有其他的线程来写数据了，这就不能保证一致性。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 4]  
现在，需要对读和写操作来加锁保护。

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();
        }
    
    }

这样，写的操作就能够保证一致性了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 5]

#### 6.BlockingQueue阻塞队列 ####

当队列是空的，从队列中获取元素的操作会被阻塞  
当队列是满的，从队列中添加元素的操作会被阻塞  
BlockingQueue是一个接口，其实现类有以下几种：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 6]

[20200302093308478.png]: https://img-blog.csdnimg.cn/20200302093308478.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200302094328298.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[20200302101429525.png]: https://img-blog.csdnimg.cn/20200302101429525.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200302102308923.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200302104527860.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200302104755661.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200302112701251.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200302113737404.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200302120019538.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM5NTkxMQ==,size_16,color_FFFFFF,t_70