1.多线程

1.1 线程（Thread）

线程时一个程序内部的一条执行流程，java的main方法就是由一条默认的主线程执行

1.2 多线程

    多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）

    许多平台都离不开多线程，因为多线程可以实现并发技术，只有通过多线程，才可能实现多人同时订票等功能，一个人就代表着一个线程

2. 创建多线程

Java是通过java.lang.Thread类的对象来代表线程的

2.1 线程创建方式一：继承Thread类

2.1.1 创建步骤

•     定义一个子类继承线程类java.lang.Thread，重写run( )方法，方法体交给另一个线程执行
•     创建子类对象
•     调用子类对象的start( )方法启动线程（通过start( )方法启动，cpu会自动分配线程执行run( )方法）
   

//1.子类MyThread继承Thread类
public class MyThread extends Thread{//2.重写run方法，run方法的方法体就是新的线程执行体@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("MyThread执行" + i);}}
}

public class Test1 {//main方法默认就是由一个主线程负责执行public static void main(String[] args) {//3.创建一个子类对象即新的线程对象MyThread myThread = new MyThread();//4.调用start方法，启动新线程，执行run方法myThread.start();//5.主线程中，通过for循环执行主线程的执行体for (int i = 0; i < 5; i++) {System.out.println("main线程执行" + i);}}
}

2.1.2 优缺点

优点：编码简单

缺点：java是单继承，线程类已经继承了Thread类，就无法继承其他类，不利于功能的扩展

2.1.3 注意事项

1. 启动线程必须调用start方法，不能调用run方法。直接调用run方法会被当成普通方法执行，cpu不会分配新的线程来执行run方法中的方法体，相当于还是单线程。
2. 不能把主线程任务放在启动子线程之前，否则只有主线程任务执行完才会开启新的线程，没有意义，还是相当于单线程

public class Test2 {public static void main(String[] args) {MyThread myThread = new MyThread();//如果调用run方法，那么就不是启动新的线程，而是在主线程中调用run方法myThread.run();for (int i = 0; i < 5; i++) {System.out.println("main线程执行" + i);};}
}

result：
MyThread执行0
MyThread执行1
MyThread执行2
MyThread执行3
MyThread执行4
main线程执行0
main线程执行1
main线程执行2
main线程执行3
main线程执行4
由结果可以看出变成了单线程，只有主线程负责执行

public class Test2 {public static void main(String[] args) {MyThread myThread = new MyThread();for (int i = 0; i < 5; i++) {System.out.println("main线程执行" + i);};//主程序的执行体在线程开启之前，所以先执行主程序的执行体，相当于单线程myThread.start();}
}

main线程执行0
main线程执行1
main线程执行2
main线程执行3
main线程执行4
MyThread执行0
MyThread执行1
MyThread执行2
MyThread执行3
MyThread执行4

2.2 线程创建方式二：实现Runnable接口

2.2.1 创建步骤

1. 定义一个线程任务类实现Runnable接口，重写run( )方法
2. 创建任务对象
3. 将任务对象封装成Thread( )对象
4. 调用Thread线程对象的start( )方法启动线程

//1.创建一个实现了Runnable接口的类
public class MyRunnable implements Runnable{//2.实现类去实现Runnable中的抽象方法run()@Overridepublic void run() {for (int i = 0; i < 5; i++) {System.out.println("子线程执行==》" + i);}}
}

public class Test1 {public static void main(String[] args) {//3.创建一个任务对象Runnable myRunnable = new MyRunnable();//4.将任务对象封装成一个线程对象并调用start方法new Thread(myRunnable).start();for (int i = 0; i < 5; i++) {System.out.println("main线程执行==>" + i);}}
}

result：
子线程执行==》0
main线程执行==>0
子线程执行==》1
main线程执行==>1
子线程执行==》2
main线程执行==>2
main线程执行==>3
main线程执行==>4
子线程执行==》3
子线程执行==》4

2.2.2 优缺点

优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强

缺点：需要多创建一个Runnable对象

2.2.3 使用匿名内部类改进代码

public class Test2 {public static void main(String[] args) {//使用匿名内部类的方式创建线程new Thread(new Runnable(){@Overridepublic void run() {for (int i = 0; i < 3; i++) {System.out.println("子线程1执行==>" + i);}}}).start();//使用lambda表达式创建线程new Thread(() ->{for (int i = 0; i < 3; i++) {System.out.println("子线程2执行==>" + i);}}).start();for (int i = 0; i < 3; i++) {System.out.println("main线程执行==>" + i);}}
}

2.3 线程创建方式三：实现Callable接口

2.3.1 实现步骤

• 创建任务对象
•     定义一个子类实现Callable接口，重写call方法，封装方法体和待返回数据
•     将Callable类型的对象封装成FutherTask线程任务对象
• 将FutherTask线程任务对象交给Thread对象封装
• 调用Thread线程对象的start( )方法启动线程
• 线程执行完毕后，通过FutherTask对象的get( )方法获取线程任务执行的结果
   

//1.创建一个实现Callable接口的实现类
public class MyCallable implements Callable<Double> {private int n;public MyCallable(int n) {this.n = n;}//2.重写call方法，call方法的方法体就是新的线程执行体@Overridepublic Double call() throws Exception {double sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return sum;}
}

public class Test {public static void main(String[] args) throws Exception {//3.创建一个子类对象Callable<Double> myCallable = new MyCallable(100);//4.创建一个FutureTask对象，将myCallable对象作为构造参数传入FutureTask<Double> futureTask = new FutureTask<>(myCallable);//5.创建一个Thread对象，并将FutureTask对象作为构造参数传入new Thread(futureTask).start();//创建第二个线程FutureTask<Double> futureTask2 = new FutureTask<>(new MyCallable(200));new Thread(futureTask2).start();//6.通过FutureTask对象的get方法获取call方法的返回值//如果call方法没有执行完毕，get方法会阻塞等待Double v = futureTask.get();System.out.println(v);Double v2 = futureTask2.get();System.out.println(v2);}
}

2.3.2 优缺点

优点：

• 线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；
• 可以在线程执行完毕后去获取线程执行的结果

缺点：编码比较复杂

3.线程常用方法：

4. 线程安全问题

4.1 线程安全问题出现的原因

5.1 认识线程同步

5.1.1 线程同步的思想

让多个线程实现先后依次访问共享资源，这样就解决了安全问题

5.1.2 线程同步的常见方案

加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来

• 同步代码块
• 同步方法
• Lock锁

5.2 三种加锁方式

//修改4.2.1的程序中Account类中的drawMoney( )方法，其余部分代码不变
//快捷键：ctrl+alt+tpublic void drawMoney(double drawMoney){String name = Thread.currentThread().getName();//同步代码块synchronized (this) {if (money >= drawMoney){System.out.println(name + "取钱成功，吐出钞票：" + drawMoney);money -= drawMoney;System.out.println(name + "取钱后的余额为：" + money);}else {System.out.println(name + "取钱失败，余额不足！");}}}
/*小明取钱成功，吐出钞票：100000.0小明取钱后的余额为：0.0小红取钱失败，余额不足！*/

//示例public static void test(){//同步代码块synchronized (Account.class) {}}

//修改4.2.1的程序中Account类中的drawMoney( )方法，其余部分代码不变
//使用synchronized修饰方法，同步方法public synchronized void drawMoney(double drawMoney){String name = Thread.currentThread().getName();//同步代码块if (money >= drawMoney){System.out.println(name + "取钱成功，吐出钞票：" + drawMoney);money -= drawMoney;System.out.println(name + "取钱后的余额为：" + money);}else {System.out.println(name + "取钱失败，余额不足！");}}
/*小明取钱成功，吐出钞票：100000.0小明取钱后的余额为：0.0小红取钱失败，余额不足！*/

//修改4.2.1的程序中Account类中的drawMoney( )方法，其余部分代码不变//创建锁对象private final Lock lock = new ReentrantLock();public void drawMoney(double drawMoney){String name = Thread.currentThread().getName();//使用try\cathc\finally代码块来确保锁一定会被释放,//否则一旦代码块中出现异常，锁就不会被释放try {//加锁lock.lock();if (money >= drawMoney){System.out.println(name + "取钱成功，吐出钞票：" + drawMoney);money -= drawMoney;System.out.println(name + "取钱后的余额为：" + money);}else {System.out.println(name + "取钱失败，余额不足！");}} catch (Exception e) {throw new RuntimeException(e);} finally {//释放锁lock.unlock();}}
/*小明取钱成功，吐出钞票：100000.0小明取钱后的余额为：0.0小红取钱失败，余额不足！*/

public class Desk {private List<String> list=new ArrayList<>();public synchronized void put(){try {String name = Thread.currentThread().getName();if(list.isEmpty()){list.add(name+" 做的包子");System.out.println(name+" 做的包子");Thread.sleep(1000);}this.notifyAll();this.wait();} catch (Exception e) {throw new RuntimeException(e);}}public synchronized void get(){try {String name = Thread.currentThread().getName();if(!list.isEmpty()){list.clear();System.out.println(name+" 吃了包子");Thread.sleep(100);}this.notifyAll();this.wait();} catch (Exception e) {throw new RuntimeException(e);}}}

public class Test {public static void main(String[] args) {Desk desk = new Desk(); //创建桌子对象//创建厨师线程new Thread(()->{while (true) {desk.put();}}, "厨师1").start();new Thread(()->{while (true) {desk.put();}}, "厨师2").start();new Thread(()->{while (true) {desk.put();}}, "厨师3").start();//创建吃货线程new Thread(()->{while (true) {desk.get();}}, "吃货1").start();new Thread(()->{while (true) {desk.get();}}, "吃货2").start();}
}

7.1 认识线程池

7.1.1 什么是线程池

线程池就是一个可以复用线程的技术

7.1.2 不使用线程池的问题

用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。

7.1.3 线程池的工作原理

1. 如果线程池中有三个工作线程，则每个线程都会处理任务队列中的一个任务
2. 当某个线程处理完一个任务后，该线程会继续处理任务队列中的其他任务，依次类推

7.2 创建线程池

JDK5.0起提供了代表线程池的接口：ExecutorService

7.1.1 创建线程池对象的方式一（推荐使用）

使用实现了ExecutorService接口的实现类ThreadPoolExecutor创建线程池对象

ThreadPoolExecutor构造器

//格式
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)

//实例
public class Test{public static void main(String[] args) {// 创建线程池方式一/*线程池中有三个核心线程线程池中有五个最大线程线程池中有（5-3=2）个临时线程临时线程的存活时间为8秒线程池中有4个任务队列拒绝策略为：抛出异常并丢弃任务*/new ThreadPoolExecutor(3,5,8, TimeUnit.SECONDS,new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());}
}

• 参数一：corePoolSize：指定线程池的核心线程的数量。（相当于饭店的固定服务员的数量）
• 参数二：maximumPoolSize：指定线程池的最大线程数量。（相当于饭店的固定服务员和临时员工的数量）
• 参数三：keepAliveTime：指定临时线程的存活时间。（相当于临时员工可以干多久）
• 参数四：unit：指定临时线程存活的时间单位（秒、分、时、天）
• 参数五：workQueue：指定线程池的任务队列。（相当于待招待的客人的数量）
• 参数六：threadFactory：指定线程池的线程工厂。（相当于负责招聘服务员的hr）
• 参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）（相当于饭店的临时工和固定服务员仍然忙不过来时，应该如果对待新来的客人）
   

//创建Runnable任务类
public class MyRunnable implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "线程==>被调用了");try {//让线程睡眠一会，从而便于模拟并发环境Thread.sleep(Integer.MAX_VALUE);} catch (InterruptedException e) {throw new RuntimeException(e);}}
}

public class Test{public static void main(String[] args) {// 创建线程池ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());// 创建Runnable任务实例对象Runnable target = new MyRunnable();//下面的三个任务被三个核心线程处理，不占用任务队列中的空间pool.execute(target);//该方法会在线程池中自动创建一个新线程自动处理任务，前提是线程池中有空闲线程pool.execute(target);pool.execute(target);//下面的四个任务进入任务队列等待处理pool.execute(target);pool.execute(target);pool.execute(target);pool.execute(target);//当任务队列满了并且核心线程全部被占用，会创建临时线程处理任务，//但是只能创建两个临时线程，因为最大线程数为5//下面的两个任务会被临时线程处理pool.execute(target);pool.execute(target);
//        下面的两个任务因为临时线程已经达到最大线程数，所以会根据拒绝策略进行处理pool.execute(target);}
}
/*
结果见下图此时由于三个核心线程被占用，四个任务也在任务队列中等待处理，两个临时线程也被占用，所以会根据拒绝策略进行任务处理*/

7.1.2 创建线程池对象的方式二（不推荐使用）

使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象

Executors是一个线程池工具类，提供了许多静态方法用于返回不同特点的线程池对象

 这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象

缺点：大型并发系统环境中使用Executors?如果不注意可能会出现系统风险

1. FixedThreadPool和SingleThreadPool

   允许的请求队列长度为Integer.MAX VALUE,可能会堆积大量的请求，从而导致OOM(内存溢出)。

2. CachedThreadPool

   允许的创建线程数量为Integer.MAX VALUE,可能会创建大量的线程，从而导致OOM(内存溢出)。

使用线程池处理任务

注意：一般不会关闭线程池，如果实在需要关闭，则使用void shutdown( )方法关闭

//1.创建一个实现Callable接口的实现类
public class MyCallable implements Callable<Double> {private int n;public MyCallable(int n) {this.n = n;}//2.重写call方法，call方法的方法体就是新的线程执行体@Overridepublic Double call() throws Exception {double sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return sum;}
}

public class Test3 {public static void main(String[] args) throws Exception{//创建线程池ExecutorService pool = Executors.newFixedThreadPool(3);//创建Callable任务对象Callable<Double> c1 = new MyCallable(100);Callable<Double> c2 = new MyCallable(200);Callable<Double> c3 = new MyCallable(300);//执行任务并获取Future对象Future<Double> s1 = pool.submit(c1);Future<Double> s2 = pool.submit(c2);Future<Double> s3 = pool.submit(c3);//输出结果System.out.println(s1.get());System.out.println(s2.get());System.out.println(s3.get());}
}

8. 并发、并行、线程的生命周期

8.1 并发与并行

8.1.1 进程

• 正在运行的程序（软件）就是一个独立的进程。
• 线程是属于进程的，一个进程中可以同时运行很多个线程。
• 进程中的多个线程其实并发和并行执行的。

8.1.2 并发

进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

8.1.3 并行

在同一个时刻上，同时有多个线程在被CPU调度执行。

8.2.1 Java线程的状态

• Java定义了六种状态
• 定义在Thread类的内部枚举类中

public enum State {NEW,RUNNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED;}