Lock

通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentranLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentranLock，可以显式加锁和释放锁。

代码

import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
    private int ticket=100;
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                //调用lock方法 加锁
                lock.lock();
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+"：售票，票号为"+ticket);
                    ticket--;
                }
                else break;
            }finally {
                //解锁
                lock.unlock();
            }

        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

synchronized和Lock的异同

相同

都可以用来解决线程安全问题

不同

synchronized机制执行完相应的代码逻辑后会自动释放同步监视器，
Lock需要手动启动同步，也需要手动结束同步。

sleep()和wait()的异同

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：

两个方法声明的位置不同：Thread类中声明sleep()。Object类中声明wait（）
调用的要求不同：sleep()可以在任何需要的场景下调用，wait()必须在同步代码块或者同步方法中调用。
关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

实现Callable接口

功能

与使用Runnable相比，Callable功能更强大些

相比run()方法，可以有返回值
方法可以抛出异常
支持泛型的返回值
需要借助FutureTask类，比如获取返回结果

Future接口

可以对具体Runnable和Callable任务的执行结果进行取消，查询是否完成，获取结果等。
FutureTask是Future接口唯一的实现类。
FutureTask同时实现了Runnable，Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

代码

import java.util.ArrayList;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class NumThread implements Callable {
    @Override
    public Object call() throws Exception{
        int sum=0;
        for(int i=1;i<=100;i++){
            if(i%2==0){
                System.out.println(i);
                sum+=i;
            }
        }
        return sum;
    }
}

public class Main {
    public static void main(String[] args) {
        //创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        try {
            //获取Callable中call方法的返回值
            //get()返回值即为futureTask
            Object sum = futureTask.get();
            System.out.println("总和为："+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

线程池

背景

经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路

提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具

好处

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理：corePoolSize：核心池的大小 maximumPoolSize：最大线程数 keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程池相关API

ExecutorService

真正的线程池接口，常见子类ThreadPoolExecutor

void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable
Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable
void shutdown():关闭连接池

Executors

工具类，线程池的工厂类，用于创建并返回不同类型的线程池

Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池。
Executors.newFixedThreadPool(n)：创建一个可重用固定线程数的线程池
Executors.newSingleThreadExecutor()：创建一个只有一个线程的线程池
Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

代码

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class NumberThread implements Runnable {
    @Override
    public void run() {
        int sum=0;
        for(int i=1;i<=100;i++){
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //执行指定的线程的操作 需要提供实现Runnable接口或Callable接口实现类的对象
        executorService.execute(new NumberThread()); //适用于runnable
//        executorService.submit(Callable callable);//适用于callable
        executorService.shutdown();

    }
}