业务需求
电影院新片首映，观影人数大量增加，为提高日营业额，线下售票窗口由原单窗口调整为3窗口，设计一段简单的程序模拟该售票过程。
程序设计
多线程场景下需考虑线程安全的问题，避免多个线程争抢同一个资源导致业务逻辑出现错误。实现线程安全的方式有很多，这里使用Java Lock 接口中的方法实现。
代码示例

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试类
 */
public class DemoTest {
    public static void main(String[] args) {

        //窗口01
        new Thread(() -> {
            while (true) {
                //售票并获取售票后的当前票余量
                int currentTickets = TicketSource.saleTickets();
                //模拟售票员卖出一张票用时1秒
                waitProcess();
                //票已卖完
                if (currentTickets <= 0) break;
            }
        }, "01").start();

        //窗口02
        new Thread(() -> {
            while (true) {
                int currentTickets = TicketSource.saleTickets();
                waitProcess();
                if (currentTickets <= 0) break;
            }
        }, "02").start();

        //窗口03
        new Thread(() -> {
            while (true) {
                int currentTickets = TicketSource.saleTickets();
                waitProcess();
                if (currentTickets <= 0) break;
            }
        }, "03").start();


    }

    private static void waitProcess() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

/**
 * 电影票资源类
 */
class TicketSource {

    //当前电影票余量
    private static int currentTickets = 30;

    //加锁确保多线程场景下的线程安全
    private static final Lock lock = new ReentrantLock();

    /**
     * 卖票
     *
     * @return 当前电影票余量
     */
    public static int saleTickets() {
        lock.lock();
        try {
            if (currentTickets > 0) {
                //模拟卖票
                currentTickets--;

                if (currentTickets == 0) {
                    //票余量为 0 停止售卖
                    System.out.println(
                            Thread.currentThread().getName() + "窗口出票成功！"
                                    + "当前票余量：" + currentTickets
                                    + " 今日票已卖完！");
                } else {
                    System.out.println(
                            Thread.currentThread().getName() + "窗口出票成功！"
                                    + "当前票余量：" + currentTickets);
                }
            } else {
                //票余量为 0 停止售卖
                System.out.println(Thread.currentThread().getName() + "窗口：今日票已卖完！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

        return currentTickets;
    }

}

运行结果

D:\installPath\Java\jdk1.8.0_121\bin\java.exe "-javaagent:D:\installPath\IntelliJ IDEA 2019.1.4\lib\idea_rt.jar=64339:D:\installPath\IntelliJ IDEA 2019.1.4\bin"
01窗口出票成功！当前票余量：29
02窗口出票成功！当前票余量：28
03窗口出票成功！当前票余量：27
01窗口出票成功！当前票余量：26
03窗口出票成功！当前票余量：25
02窗口出票成功！当前票余量：24
03窗口出票成功！当前票余量：23
01窗口出票成功！当前票余量：22
02窗口出票成功！当前票余量：21
02窗口出票成功！当前票余量：20
03窗口出票成功！当前票余量：19
01窗口出票成功！当前票余量：18
01窗口出票成功！当前票余量：17
02窗口出票成功！当前票余量：16
03窗口出票成功！当前票余量：15
02窗口出票成功！当前票余量：14
01窗口出票成功！当前票余量：13
03窗口出票成功！当前票余量：12
01窗口出票成功！当前票余量：11
03窗口出票成功！当前票余量：10
02窗口出票成功！当前票余量：9
03窗口出票成功！当前票余量：8
02窗口出票成功！当前票余量：7
01窗口出票成功！当前票余量：6
03窗口出票成功！当前票余量：5
02窗口出票成功！当前票余量：4
01窗口出票成功！当前票余量：3
01窗口出票成功！当前票余量：2
03窗口出票成功！当前票余量：1
02窗口出票成功！当前票余量：0 今日票已卖完！
01窗口：今日票已卖完！
03窗口：今日票已卖完！

Process finished with exit code 0

多线程在Java项目中的使用案例(笔记)

1. 实现runnable接口

@Override
    public Boolean addMeetingExpertIds(MeetAddExpertDto meetAddExpertDto, Long userId) {
        // 会议关联到专家
        // 如果需要发给专家
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    if (meetAddExpertDto.getExpertIdList().size() > 0) {
                        // 准备通知数据
                        List<AddMeeTempDto> addMeeTempDtoList = new ArrayList<>();
                        for (Long expertId : meetAddExpertDto.getExpertIdList()) {
                            AddMeeTempDto addMeeTempDto = new AddMeeTempDto()
                                    .setExpertId(expertId)
                                    .setTemplateDetail(meetAddExpertDto.getTemplate() + expertId);
                            addMeeTempDtoList.add(addMeeTempDto);
                        }
                        expertMeetingService.addExpertMeetingBatch(meetAddExpertDto.getMeetingId(), addMeeTempDtoList, userId);
                        Thread.sleep(300);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    log.info("线程结束");
                }
            }
        }).start();
        return true;
    }

Lambda写法

@Override
    public void test(Integer meetId) {

        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    log.info("线程" + meetId + "正在输出" + i);//逻辑代码
                    if (i == 5) {
                        Thread.sleep(200);
                        log.info("线程" + meetId + "睡眠");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                log.info("线程结束");
            }
        }).start();
    }

2. 创建线程池

@Override
    public void test(Integer meetId) {
        //创建一个具有10个线程的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        long threadpoolUseTime = System.currentTimeMillis();
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        log.info("线程" + meetId + "正在输出" + i);
                        if (i == 5) {
                            Thread.sleep(200);
                            log.info("线程" + meetId + "睡眠");
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        long threadpoolUseTime1 = System.currentTimeMillis();
        System.out.println("多线程用时"+(threadpoolUseTime1-threadpoolUseTime));
        //销毁线程池
        threadPool.shutdown();
    }

Lambda写法

@Override
    public void test(Integer meetId) {
        //创建一个具有10个线程的线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        long threadpoolUseTime = System.currentTimeMillis();
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        log.info("线程" + meetId + "正在输出" + i);
                        if (i == 5) {
                            Thread.sleep(200);
                            log.info("线程" + meetId + "睡眠");
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        long threadpoolUseTime1 = System.currentTimeMillis();
        System.out.println("多线程用时"+(threadpoolUseTime1-threadpoolUseTime));
        //销毁线程池
        threadPool.shutdown();
    }

多线程使用的主要目的在于

1、吞吐量：你做WEB，容器帮你做了多线程，但是他只能帮你做请求层面的。简单的说，可能就是一个请求一个线程。或多个请求一个线程。如果是单线程，那同时只能处理一个用户的请求。

2、伸缩性：也就是说，你可以通过增加CPU核数来提升性能。如果是单线程，那程序执行到死也就利用了单核，肯定没办法通过增加CPU核数来提升性能。

鉴于是做WEB的，第1点可能你几乎不涉及。那这里我就讲第二点吧。

举个简单的例子

假设有个请求，这个请求服务端的处理需要执行3个很缓慢的IO操作（比如数据库查询或文件查询），那么正常的顺序可能是（括号里面代表执行时间）：

1. 读取文件1 （10ms）
2. 处理1的数据（1ms）
3. 读取文件2 （10ms）
4. 处理2的数据（1ms）
5. 读取文件3 （10ms）
6. 处理3的数据（1ms）
7. 整合1、2、3的数据结果 （1ms）

单线程总共就需要34ms。

那如果你在这个请求内，把ab、cd、ef分别分给3个线程去做，就只需要12ms了。

所以多线程不是没怎么用，而是，你平常要善于发现一些可优化的点。然后评估方案是否应该使用。假设还是上面那个相同的问题：但是每个步骤的执行时间不一样了。

1. 读取文件1 （1ms）
2. 处理1的数据（1ms）
3. 读取文件2 （1ms）
4. 处理2的数据（1ms）
5. 读取文件3 （28ms）
6. 处理3的数据（1ms）
7. 整合1、2、3的数据结果 （1ms）

单线程总共就需要34ms。

如果还是按上面的划分方案（上面方案和木桶原理一样，耗时取决于最慢的那个线程的执行速度），在这个例子中是第三个线程，执行29ms。那么最后这个请求耗时是30ms。比起不用单线程，就节省了4ms。但是有可能线程调度切换也要花费个1、2ms。因此，这个方案显得优势就不明显了，还带来程序复杂度提升。不太值得。

那么现在优化的点，就不是第一个例子那样的任务分割多线程完成。而是优化文件3的读取速度。可能是采用缓存和减少一些重复读取。

首先，假设有一种情况，所有用户都请求这个请求，那其实相当于所有用户都需要读取文件3。那你想想，100个人进行了这个请求，相当于你花在读取这个文件上的时间就是28×100=2800ms了。那么，如果你把文件缓存起来，那只要第一个用户的请求读取了，第二个用户不需要读取了，从内存取是很快速的，可能1ms都不到。

伪代码

	public class MyServlet extends Servlet{
	    private static Map<String, String> fileName2Data = new HashMap<String, String>();
	    private void processFile3(String fName){
	        String data = fileName2Data.get(fName);
	        if(data==null){
	            data = readFromFile(fName);    //耗时28ms
	            fileName2Data.put(fName, data);
	        }
	        //process with data
	    }
	}

看起来好像还不错，建立一个文件名和文件数据的映射。如果读取一个map中已经存在的数据，那么就不不用读取文件了。

可是问题在于，Servlet是并发，上面会导致一个很严重的问题，死循环。因为，HashMap在并发修改的时候，可能是导致循环链表的构成！！！（具体你可以自行阅读HashMap源码）如果你没接触过多线程，可能到时候发现服务器没请求也巨卡，也不知道什么情况！

好的，那就用ConcurrentHashMap，正如他的名字一样，他是一个线程安全的HashMap，这样能轻松解决问题。

	public class MyServlet extends Servlet{
	    private static ConcurrentHashMap<String, String> fileName2Data = new ConcurrentHashMap<String, String>();
	    private void processFile3(String fName){
	        String data = fileName2Data.get(fName);
	        if(data==null){
	            data = readFromFile(fName);    //耗时28ms
	            fileName2Data.put(fName, data);
	        }
	        //process with data
	    }
	}

这样真的解决问题了吗，这样虽然只要有用户访问过文件a，那另一个用户想访问文件a，也会从fileName2Data中拿数据，然后也不会引起死循环。

可是，如果你觉得这样就已经完了，那你把多线程也想的太简单了，骚年！你会发现，1000个用户首次访问同一个文件的时候，居然读取了1000次文件（这是最极端的，可能只有几百）。What the fuckin hell!!!

难道代码错了吗，难道我就这样过我的一生！

好好分析下。Servlet是多线程的，那么

	public class MyServlet extends Servlet{
	    private static ConcurrentHashMap<String, String> fileName2Data = new ConcurrentHashMap<String, String>();
	    private void processFile3(String fName){
	        String data = fileName2Data.get(fName);
	        //“偶然”-- 1000个线程同时到这里，同时发现data为null
	        if(data==null){
	            data = readFromFile(fName);    //耗时28ms
	            fileName2Data.put(fName, data);
	        }
	        //process with data
	    }
	}

上面注释的“偶然”，这是完全有可能的，因此，这样做还是有问题。

因此，可以自己简单的封装一个任务来处理。

	public class MyServlet extends Servlet{
	    private static ConcurrentHashMap<String, FutureTask> fileName2Data = new ConcurrentHashMap<String, FutureTask>();
	    private static ExecutorService exec = Executors.newCacheThreadPool();
	    private void processFile3(String fName){
	        FutureTask data = fileName2Data.get(fName);
	        //“偶然”-- 1000个线程同时到这里，同时发现data为null
	        if(data==null){
	            data = newFutureTask(fName);
	            FutureTask old = fileName2Data.putIfAbsent(fName, data);
	            if(old==null){
	                data = old;
	            }else{
	                exec.execute(data);
	            }
	        }
	        String d = data.get();
	        //process with data
	    }
	
	    private FutureTask newFutureTask(final String file){
	        return  new FutureTask(new Callable<String>(){
	            public String call(){
	                return readFromFile(file);
	            }
	
	            private String readFromFile(String file){return "";}
	        }
	    }
	}

以上所有代码可以直接运行。

多线程最多的场景：web服务器本身；各种专用服务器（如游戏服务器）；

多线程的常见应用场景

1. 后台任务，例如：定时向大量（100w以上）的用户发送邮件；
2. 异步处理，例如：发微博、记录日志等；
3. 分布式计算