Java多线程学习（六）

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

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是一个接口，其实现类有以下几种：