优雅实现多线程

进程

• 进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。 在 Java
  中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。

线程

• 线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

线程的创建

• 实现Runnable接口

public class Test implements Runnable{
    private int count = 10;
    @Override
    public void run() {
        while (true){
            if (count <= 0){
                break;
            }
            try {
                Thread.sleep(200); //休眠200毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("当前线程为"+Thread.currentThread().getName()+"抢到第"+count--+"张票");
        }
    }
    public static void main(String[] args) {
        Test test = new Test();
        new Thread(test,"小米").start();
        new Thread(test,"小黑").start();
        new Thread(test,"小黄").start();
    }
}

• 继承Thread类

public class TestThread extends Thread {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        testThread.start();
    }
}

• 实现Callable接口

public class TestThread implements Callable<Boolean> {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestThread testThread = new TestThread();
        //创建执行服务
        ExecutorService pool = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> future = pool.submit(testThread);
        //返回结果
        Boolean aBoolean = future.get();
        //关闭服务
        pool.shutdownNow();
        System.out.println(aBoolean);
    }
    @Override
    public Boolean call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        return true;
    }
}

Synchronized

• 同步锁(锁住对象是当前方法的类Test，所以后面线程都排队进来)

public class Test implements Runnable{
    private int count = 10;
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            getbuy();
        }
    }
    //当前锁住的是Test对象，所以后面线程都排队进来
    public synchronized void getbuy(){
        if (count <= 0){
            flag = false;
            return;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程为"+Thread.currentThread().getName()+"抢到第"+count--+"张票");
    }
    public static void main(String[] args) {
        Test test = new Test();
        new Thread(test,"小米").start();
        new Thread(test,"小黑").start();
        new Thread(test,"小黄").start();
    }
}

• 代码块(锁的对象就是变化的量，需要增删改)

public class ListTest {
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                //锁的对象就是变化的量，需要增删改
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        Thread.sleep(300);
        System.out.println(list.size());
    }
}

Lock锁

public class Test2 implements Runnable{

    private int count = 10;
    boolean flag = true;
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (flag){
            try {
                //加锁
                lock.lock();
                getbuy();
            }finally {
                //释放锁
                lock.unlock();
            }
        }
    }

    public  void getbuy(){
        if (count <= 0){
            flag = false;
            return;
        }
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前线程为"+Thread.currentThread().getName()+"抢到第"+count--+"张票");
    }

    public static void main(String[] args) {
        Test2 test = new Test2();
        new Thread(test,"小米").start();
        new Thread(test,"小黑").start();
        new Thread(test,"小黄").start();
    }
}

线程池

public class Test3 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args) {
        //创建线程池大小
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        //执行线程
        executorService.execute(new Test3());
        executorService.execute(new Test3());
        executorService.execute(new Test3());
        executorService.execute(new Test3());
        //关闭连接
        executorService.shutdownNow();
    }
}