多线程
一 什么是线程
线程（Thread）是一个程序内部的一条执行流程。如果程序中只有一条执行流程，那么这个程序就是单线程程序。
二 什么是多线程
多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）。
三 多线程的创建方式
（一）继承Thread类
实现步骤：
1. 定义一个MyThread子类继承线程类(java.lang.Thread)，重写run()方法
2. 创建MyThread子类对象
3. 调用Mythread子类对象（线程对象）的start方法启动线程。注意：启动之后是执行run()方法的
优缺点：优点：编码简单
缺点：线程类已经继承Thread类，无法再继承其他类，不利于功能的扩展。
代码演示：
//主程序代码
package CreateThreadPa1;
/**
* 创建子类继承Thread类
* 重写run()方法
* 创建子类对象代表一个线程
* 调用子类对象的start()方法启动线程
*/
public class CreateThreadDemo1 {
//main方法是由一条默认的主线程负责执行
public static void main(String[] args) {
//创建子类对象，代表一个线程，采用多态的写法
Thread thread = new MyThread();
//调用子类对象的start()方法，启动线程，默认执行子类中重写的run()方法
thread.start();
for(int i=0;i<5;i++)
{
System.out.println("主线程main执行了"+i);
}
}
}
//子类代码
package CreateThreadPa1;
public class MyThread extends Thread{
@Override
public void run()
{
for(int i=0;i<5;i++)
{
System.out.println("子线程执行了"+i);
}
}
}
注意事项：
1. 启动线程必须是调用start()方法，而不是调用run()方法。因为如果是调用了run()方法，那么就会把创建的子类对象当成一个普通的java对象，而不是线程对象，那么就永远先去执行子类中的run()方法了，此时就属于单线程了。
2. 要把主线任务放在启动子线程之后。此时要注意一下：如果说把主线任务放在启动子线程之前，那么就永远会先去执行主线任务的代码了，此时就产生了不公平性。
（二）实现Runnable接口
实现步骤：
1. 创建线程任务类MyRunnable，实现Runnable接口，重写run()方法
2. 创建MyRunnable任务类对象
3. 调用有参构造器创建线程类对象，包装任务类对象
4. 调用线程对象的start()方法启动线程
优点：任务类只是实现了接口，可以继续继承其他类，实现其他接口，扩展性比较强。
缺点：需要多创建一个Runnable对象
代码演示：
主程序代码：
package CreateThreadPa1;
/**
* 创建线程任务类实现Runnable接口，重写run()方法
* 创建任务类对象
* 调用有参构造器，创建线程类对象，包装任务类对象，
* 启动start()方法
*/
public class CreateThreadDemo2 {
public static void main(String[] args) {
//创建任务类对象，并且采用接口变量去存储
Runnable ru = new MyRunnable();
//创建线程对象，包装任务类对象
Thread thread = new Thread(ru);
//调用线程对象的start()方法启动线程
thread.start();
for(int i=0;i<5;i++)
{
System.out.println("主线程执行了"+i);
}
}
}
任务类代码：
package CreateThreadPa1;
public class MyRunnable implements Runnable{
@Override
public void run()
{
for(int i=0;i<5;i++)
{
System.out.println("子线程执行了"+i);
}
}
}
//采用匿名内部类的写法
package CreateThreadPa1;
/**
* 创建线程任务类实现Runnable接口，重写run()方法
* 创建任务类对象
* 创建线程类对象，包装任务类对象，启动start()方法
*/
public class CreateThreadDemo2 {
public static void main(String[] args) {
//匿名内部类的写法。
//实际上相当于一个子类，这个子类实现了Runnable接口，称为是实现类，
// 并且重写了run()方法，返回一个子类对象
Runnable ru = new Runnable() {
@Override
public void run() {
for(int i=0;i<5;i++)
{
System.out.println("子线程1执行了"+i);
}
}
};
//使用Lambda表达式进行简化
Runnable runnable = () ->
{
for(int i=0;i<5;i++)
{
System.out.println("子线程4执行了"+i);
}
};
new Thread(runnable).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<5;i++)
{
System.out.println("子线程2执行了"+i);
}
}
}).start();
//简化形式
new Thread(() ->
{
for(int i=0;i < 5;i++) System.out.println("子线程3执行了"+i);
}).start();
Thread thread = new Thread(ru);
thread.start();
for(int i=0;i<5;i++)
{
System.out.println("主线程1执行了"+i);
}
}
}
(三) 实现Callable接口
实现步骤：
1. 创建任务对象。
定义一个类实现Callable接口(泛型接口)，重写call()方法，封装要做的事情和要返回的数据。
把Callable类型的对象封装成FutureTask（线程任务对象）
2. 调用构造器创建线程对象封装线程任务对象
3. 调用Thread对象的start()方法启动线程
4. 线程执行完毕之后，调用FutureTask对象的get()方法获取线程任务执行的结果。
常见构造器将其方法：
//构造器
//把Callable对象封装FutureTask对象
public FutureTask(Callable callable)
//常见方法
//获取线程执行call()方法的结果
public V get() throws Exception
代码演示：
//主程序代码
package CreateThreadPa2;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
/**
* 创建一个MyCallable类，实现Callable泛型接口，重写call方法
* 创建MyCallable对象，封装数据
* 将MyCallable对象封装成FutureTask对象(线程任务对象)
* 把FutureTask对象封装成线程对象，调用start方法启动线程
* 通过FutureTask对象的get方法获取线程的返回结果
*/
public class CreateThreadDemo1 {
public static void main(String[] args) throws Exception{
//创建一个MyCallable对象，采用多态的写法，即父类变量指向子类对象
Callable<String> call= new MyCallable(100);
//把MyCallable对象封装成FutureTask对象
//FutureTask对象(未来任务对象)的作用：
//1. 是一个任务对象，实现了Runnable接口
//2. 可以在线程执行完成之后，通过get方法获取线程执行完成之后的结果。
FutureTask<String> fu = new FutureTask<>(call);
//把FutureTask未来任务对象封装成Thread线程对象，调用线程对象的start方法启动线程
new Thread(fu).start();
//在获取线程结束之后返回的结果时，如果线程还没结束，此时主线程就会暂停，等子线程执行结束之后才会开始执行
//即保证一定会获得返回的结果。
String ans = fu.get();
System.out.println(ans);
}
}
//类中代码
package CreateThreadPa2;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n)
{
this.n = n;
}
@Override
public String call() throws Exception {
int ans = 0;
for(int i=1;i<=n;i++)
{
ans+=i;
}
return "1到"+n+"的和为："+ans;
}
}
优点：线程任务类只是实现了接口，还可以继续继承类和实现接口，扩展性比较强，而且可以在线程执行完毕之后获取callI()方法的结果。
缺点：编码复杂一点。
四 Thread的常用方法及其构造器：
//构造器
//创建线程对象，指定线程名称
public Thread(String name)
//创建线程对象，封装Runnable对象
public Thread(Runnable target)
//封装Runnable对象为线程对象，并且指定线程名称
public Thread(Runnable target,String name)
//常见方法
//线程的任务方法
public void run()
//启动线程
public void start()
//获取当前线程的名称，名称默认是Thread-索引
public String getName()
//为线程设置名称
public void setName(String name)
//获取当前执行的线程对象
public static Thread currentThread()
//让当前执行的线程休眠多少毫秒后，再继续执行
public static void sleep(long time)
//让调用当前这个方法的线程先执行完
public final void join()
代码演示：
//主程序代码
package CreateThreadPa2;
public class regularMethodsDemo1 {
public static void main(String[] args) {
//创建线程对象，并且用Thread类型的变量去存储
Thread th1 = new MyThread("1号线程",5);
//线程对象的setName()方法，为线程设置名称,也可以通过构造器进行设置名称
// th1.setName("1号线程");
//start方法启动线程
th1.start();
//getName()方法，获取线程的名称
System.out.println(th1.getName());
Thread th2 = new MyThread("2号线程",5);
// th2.setName("2号线程");
th2.start();
System.out.println(th2.getName());
//静态方法currentThread方法，获取当前正在执行的线程对象
Thread current = Thread.currentThread();
// current.setName("主线程");
System.out.println(current.getName());
for(int i=0;i<5;i++)
{
System.out.println(current.getName()+"执行了"+i);
}
}
}
//类中代码
package CreateThreadPa2;
public class MyThread extends Thread{
private int n;
public MyThread()
{
}
public MyThread(String name,int n)
{
super(name);
this.n = n;
}
@Override
public void run()
{
Thread cu = Thread.currentThread();
for(int i=0;i<n;i++)
{
System.out.println(cu.getName()+"执行了"+i);
}
}
}
package CreateThreadPa2;
public class ThreadDemo3 {
public static void main(String[] args) throws Exception{
Thread t1 = new MyThread("1号线程",2);
t1.start();
//join方法：哪个线程对象调用这个方法，就让哪个线程先执行完
t1.join();
Thread t2 = new MyThread("2号线程",2);
t2.start();
t2.join();
Thread t3 = new MyThread("3号线程",2);
t3.start();
t3.join();
for(int i = 0;i < 10;i++)
{
System.out.println(i);
//Thread类提供的静态方法sleep方法，让当前正在执行的线程休眠几秒
if(i==3) Thread.sleep(2000);
}
}
}
五 线程安全
（一）什么是线程安全问题
线程安全问题就是当多个线程，同时操作同一个共享资源的时候，可能会出现的业务安全问题。例如：银行取钱业务，更新余额的时候可能就会出现业务安全问题。
1. 线程安全问题出现的原因：
1. 存在多个线程同时执行
2. 同时访问同一个共享资源
3. 存在修改共享资源
一句话来说就是当多个线程同时访问同一个共享资源，且存在修改资源的时候，就会出现线程安全问题。。
（二）用程序模拟线程安全问题
需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元，模拟两个人同时去取钱十万元。
分析：
- 需要创建一个账户类，接着创建一个账户对象来代表两个人的共享账户。
- 需要创建一个线程类（用于创建两个线程，分别代表小明和小红）
- 创建两个线程，传入同一个账户对象给两个线程进行处理。
- 启动两个线程，同时去一个账户对象中取钱十万。
代码演示：
//账户类代码：
package ThreadPa2;
public class Account {
private String ID;
private double money;
public Account() {
}
public Account(String ID, double money) {
this.ID = ID;
this.money = money;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public void drawMoney(double money) {
//调用Thread类的currentThread()方法，获取当前正在执行的线程对象
String name = Thread.currentThread().getName();
if(this.money>=money)
{
System.out.println(name+"取钱"+money+"成功!");
this.money-=money;
System.out.println(name+"取钱之后，剩余"+this.money+"元");
}
else
{
System.out.println(name+"来取钱，余额不足，当前余额为"+money+"元");
}
}
}
//主程序代码
package ThreadPa2;
public class ThreadDemo1 {
public static void main(String[] args) {
//创建帐户类对象，表示一个共享账户
Account acc = new Account("Dsada_a",100000);
//创建线程类对象，指定线程名称，调用start()方法，启动线程
new DrawThread("小明",acc).start();
new DrawThread("小红",acc).start();
}
}
//线程类代码
package ThreadPa2;
public class DrawThread extends Thread{
private Account account;//存储账户
public DrawThread(String name,Account account)
{
super(name);//调用父类构造器，设置线程对象的名称
this.account = account;
}
@Override
public void run() {
//调用实例方法，进行取钱操作
account.drawMoney(100000);
}
}
六 线程同步
（一）什么是线程同步
线程同步就是解决线程安全问题的方案。
线程同步的思想：让多个线程实现先后依次访问共享资源，这样就解决了线程安全的问题。
（二）线程同步的常见方案
1. 什么是加锁
加锁：当多个线程要同时访问一个共享资源的时候，每次只允许一个线程加锁，加锁之后才能去访问共享资源，而其他线程必须等待解锁之后才能继续加锁访问共享资源，访问完毕之后会自动解锁。
2. 方式一：同步代码块
2.1 作用及其原理
**作用：**把访问共享资源的核心代码块给上锁，以此保证线程安全。
格式：
synchronized (锁对象：在实例方法中建议使用this作为锁对象，正好代表一个共享资源，不会干扰别人，而在静态方法中建议使用类名.class作为锁对象)
{
访问共享资源的核心代码块
}
**原理：**每次只允许一个线程加锁后进入，执行完成之后会自动解锁，然后其他线程才可以进来继续执行。
**注意事项：**对于当前同时执行的线程来说，同步锁必须同一把(同一个对象)，否则就会出现bug。
代码演示：
//账户类代码
package ThreadPa2;
public class Account {
private String ID;
private double money;
public Account() {
}
public Account(String ID, double money) {
this.ID = ID;
this.money = money;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public static void text()//对于静态方法中的锁对象，采用类名.class作为锁对象
{
synchronized(Account.class)
{
System.out.println("啥也不是");
}
}
public void drawMoney(double money) {
String name = Thread.currentThread().getName();
//对修改共享资源的核心代码块加锁，当小明线程和小红线程过来的时候，会争夺锁对象，
// 只允许一个线程加锁之后进入，另一个线程则会等待解锁之后才能加锁进入
//对于实例方法中的锁对象，建议采用this作为锁对象即可,实际上还可以采用双引号得到的字符串对象
//来作为锁，但是这种锁会锁住所有人，不建议使用。就相当于家里的大门，自己门锁了并不能限制其他家的
//人开门回自己的家。
synchronized (this) {
if(this.money>=money)
{
System.out.println(name+"取钱"+money+"成功!");
this.money-=money;
System.out.println(name+"取钱之后，剩余"+this.money+"元");
}
else
{
System.out.println(name+"来取钱，余额不足，当前余额为"+this.money+"元");
}
}
}
}
//主程序代码
package ThreadPa2;
public class ThreadDemo1 {
public static void main(String[] args)
{
//调用有参构造器创建账户对象，同时进行初始化，指定账户的卡号和金额
Account acc = new Account("8787521",100000);
//调用有参构造器创建线程类对象，同时进行初始化，指定线程的名称和账户
new DrawThread("小明",acc).start();
new DrawThread("小红",acc).start();
Account acc1 = new Account("123",100000);
Thread th1 = new DrawThread("小黑",acc1);
th1.start();
Thread th2 = new DrawThread("小兰",acc1);
th2.start();
}
}
//线程类代码
package ThreadPa2;
public class DrawThread extends Thread{
private Account account;//实例变量account，用来存储账户对象
构造器，对线程对象进行初始化，指定线程对象的名称以及线程对象的账户对象
public DrawThread(String name,Account account)
{
//调用父类的构造器，为线程对象设置名称
super(name);
this.account = account;
}
//run方法，线程任务方法，调用start方法之后会自动执行run方法
@Override
public void run() {
account.drawMoney(100000);
}
}
2.1 锁对象的使用规范
锁对象是不建议随便选择一个唯一的对象的，因为会影响其无关线程的执行。
使用规范：
1. 建议使用共享资源作为锁对象，对于实例方法this就是共享资源，建议使用this作为锁对象。
2. 对于静态方法建议使用字节码(类名.class)作为锁对象。
3. 方式二：同步方法
3.1 作用
把访问共享资源的的核心方法给上锁，以此保证线程安全。
格式：在方法上加上synchronized修饰即可，这里就不演示。
修饰符 synchronized 返回值类型 方法名称（形参列表）
{
操作共享资源的代码
}
3.2 原理
每次只允许一个线程进入，执行完成之后自动解锁，其他线程才可以进来执行。
底层原理：
1. 同步方法其实底层也是有锁对象的，只是隐含了而已，锁的范围是整个方法代码。
2. 如果说方法是实例方法：同步方法默认用this作为锁对象
3. 如果说方法是静态方法：同步方法采用类名.class作为锁对象
4. 同步代码块和同步方法比较
范围上：同步代码块锁的范围比较小，同步方法锁的范围比较大。
可读性：同步方法可读性比较好。
5. 方式三：Lock锁
Lock锁是一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更加灵活 更加方便 更加强大。
Lock是接口，因此是不能直接创建对象的，即不能直接实例化，可以采用它的实现类ReentrantLock来创建Lock锁对象。然后就可以调用lock()方法和unlock()方法进行加锁和解锁。
建议：在采用Lock锁对象进行加锁和解锁的时候，建议使用try catch finally语句。因为一旦代码出现了问题，也会执行解锁操作，比较好。此外，在创建锁对象的时候，存储对象的变量建议使用final进行修饰，保证不能被修改。
//构造器
//获得Lock锁的实现类对象
public ReentrantLock()
//常见方法
//获得锁
public void lock()
//释放锁
public void unlock()
代码演示：
package ThreadPa2;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Account
{
private String ID;
private double money;
//创建Lock锁对象，并且用final进行修饰，表示lock锁对象不能被修改,采用多态的写法
private final Lock lo = new ReentrantLock();
public Account() {
}
public Account(String ID, double money) {
this.ID = ID;
this.money = money;
}
public String getID() {
return ID;
}
public void setID(String ID) {
this.ID = ID;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
public void drawMoney(double money) {
String name = Thread.currentThread().getName();
try {
//lock()方法，加锁
lo.lock();
if(this.money>=money)
{
System.out.println(name+"取钱"+money+"成功!");
this.money-=money;
System.out.println(name+"取钱之后，剩余"+this.money+"元");
}
else
{
System.out.println(name+"来取钱，余额不足，当前余额为"+this.money+"元");
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
//解锁
lo.unlock();
}
}
}
七 线程通信
（一）什么是线程通信
线程通信就是当多个线程共同操作共享的资源时，线程之间通过某种方式相互告知自己的状态，以相互协调，避免无效的资源争夺。
//Object类的等待和唤醒方法
//让当前线程等待并且释放所占锁，直到另一个线程调用notify方法或者notifyAll方法
void wait()
//唤醒正在等待的单个线程
void nitify()
//唤醒正在等待的所有线程
void notifyAll()
注意：上述方法应当使用当前同步锁对象(this)进行调用，因为只有锁对象才知道哪个线程正在执行以及哪个线程正在等待。
（二）常见模型
生产者和消费者模型：
1. 生产者线程负责生产数据
2. 消费者负责消费生产者生产的数据
注意：生产者生产完数据之后必须等待自己，通知消费者消费，消费者消费完数据之后也应该等待自己，再通知生产者生产。
代码演示：
//类中代码
package ThreadTest1;
import java.util.ArrayList;
import java.util.List;
public class Desk {
//创建一个list集合对象，用于存放包子
private List<String> arr =new ArrayList<>();
//放包子的方法
public synchronized void put()
{
//调用Thread类提供的方法currentThread方法，获取
//当前正在执行的线程对象，获取线程的名称
String name = Thread.currentThread().getName();
try {
if(arr.size()==0)
{
arr.add(name+"做了包子");
System.out.println(name+"放了一个包子");
Thread.sleep(2000);
//通过锁对象调用Object类提供的的notifyAll方法
//唤醒所有正在等待的线程
this.notifyAll();
//调用wait方法让当前正在执行的等待，知道另一个线程
//调用notify获得notify方法
this.wait();
}
else
{
this.notifyAll();
this.wait();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
//吃包子的方法
public synchronized void eat() {
String name = Thread.currentThread().getName();
try {
if(arr.size()==1)
{
arr.clear();
System.out.println(name+"来吃了一个包子");
Thread.sleep(1000);
this.notifyAll();
this.wait();
}
else
{
this.notify();
this.wait();
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
//主程序代码
package ThreadTest1;
public class ThreadDemo1 {
public static void main(String[] args) {
//创建一个桌子对象
Desk desk = new Desk();
//采用匿名内部类的写法创建线程对象，启动线程。
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
desk.put();
}
}
},"厨师1").start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
desk.put();
}
}
},"厨师2").start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
desk.put();
}
}
},"厨师3").start();
new Thread(() -> {
while (true) {
desk.eat();
}
},"吃货1").start();
new Thread(() -> {
while (true) {
desk.eat();
}
},"吃货2").start();
}
}
八 线程池
（一）什么是线程池
线程池就是一个可以复用线程的技术。简单来说就是线程池可以去控制线程的数量，重复地去利用线程，也可以控制任务的数量，把任务缓存起来。因此，采用线程池不会因为线程过多或者任务过多而导致系统瘫痪，可以去提高系统的工作性能。
不使用线程池的问题：
用户每发起一个请求，后台就需要创建一个新的线程出来，下次新任务来了肯定又要创建新的线程进行处理的。而创建新线程的开销是很大的，并且请求过多的时候，肯定会产生大量的线程出来，这样会严重影响系统的性能。
（二）如何创建线程池
在java当中，提供了代表线程池的接口：ExecutorService。
线程池的注意事项：
1. 临时线程是什么时候创建的？
新任务提交的时候，发现核心线程都在忙，任务队列也满了，此时如果还可以创建临时线程的话，才会去创建临时线程。
2. 什么时候会开始拒绝新任务
新任务提交时，发现核心线程和临时线程都在忙，并且任务队列也满了，那么就会拒绝任务。
创建线程池对象的方案：
1. 方式一
使用ExecutorService接口的实现类ThreadPoolExecutor来创建对象代表一个线程池对象。
常见构造器：ThreadPoolExecutor构造器
//构造器
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)
//参数解释：
corePoolSize:表示线程池的核心线程数量
maximumPoolSize：表示线程池的最大线程数量
keepAliveTime：指定临时线程的存活时间
unit：临时线程存活的时间单位(秒 分 时 天)
workQueue：指定线程池任务队列
threadFactory:指定线程池的线程工厂，用于创建线程
handler：指定线程池的任务拒绝策略(线程都在忙，任务队列也满了的时候，新任务来了怎么进行处理)
2. 方式二
使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象。
//常见方法：
//创建固定线程数量的线程池对象，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程来替代它。
public static ExecutorService newFixedThreadPool(int nThreads)
//创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新的线程。
public static ExecutorService newSingleThreadExecutor()
//线程的数量随着任务的增加而增加，如果线程任务执行完毕之后空闲了60秒则会被回收掉。
public static ExecutorService newCachedThreadPool()
//创建一个线程池对象，可以实现在给定的延迟后运行任务或者定期执行任务。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
//注意：实际上Executors工具类的静态方法的底层也是通过线程池的实现类ThreadPoolExecutor()来创建线程池对象的。
代码演示：
package CreateThreadPool;
import java.util.concurrent.*;
/**
* 创建线程池：java当中ExecutorService代表线程池，是一个接口，因此可以通过它的实现类
* ThreadPoolExecutor来创建线程池对象
*
*/
public class CreatePoolDemo1 {
public static void main(String[] args) throws Exception{
// int corePoolSize,
// int maximumPoolSize,
// long keepAliveTime,
// TimeUnit unit,
// BlockingQueue<Runnable> workQueue,
// ThreadFactory threadFactory,
// RejectedExecutionHandler handler) {
//创建一个线程池对象
// ExecutorService es = new ThreadPoolExecutor(3,5,10,TimeUnit.SECONDS,
// new ArrayBlockingQueue<>(4),Thread::new,new ThreadPoolExecutor.CallerRunsPolicy());
// ExecutorService es = new ThreadPoolExecutor(3,5,5,TimeUnit.SECONDS,
// new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
//利用Executors线程池工具类提供的静态的方法来获得线程池对象，实际上底层还是通过ThreadPoolExecutor实现的
//newFixedThreadPool方法，创建固定数量的线程池对象
ExecutorService es = Executors.newFixedThreadPool(3);//创建线程数量为3的线程池对象
// //线程池处理Callable任务,调用线程对象的submit方法,返回未来任务对象，然后调用get方法可以获取线程处理的结果
//调用submit方法，执行Callable任务，创建新线程，自动执行
Future<String> s1 = es.submit(new MyCallable(100));
//调用submit方法，执行Callable任务，创建新线程，自动执行
Future<String> s2 = es.submit(new MyCallable(200));
//调用submit方法，执行Callable任务，创建新线程，自动执行，返回未来任务对象
Future<String> s3 = es.submit(new MyCallable(300));
//复用核心线程，
Future<String> s4 = es.submit(new MyCallable(400));
//调用未来任务对象的get方法获取线程执行的结果
System.out.println(s1.get());
System.out.println(s2.get());
System.out.println(s3.get());
System.out.println(s4.get());
//shutdown方法，当线程池中的任务执行完之后，会关闭线程池
es.shutdown();
}
}
3. 核心线程数量的配置
建议：如果是计算密集型的任务：核心线程数量 = cpu的核数 + 1
如果是IO密集型的任务：核心线程数量 = cpu的核数 * 2
4. 注意：
(三) 线程池处理Runnable任务
ExecutorService的常用方法：
//执行Runnable任务
void execute(Runnable command)
//执行Callable任务，返回未来任务对象，用于获取线程返回的结果
Future<T> submit(Callable<T> task)
//等全部任务执行完毕之后，再关闭线程池
void shutdown()
//立刻关闭线程池，停止正在执行的任务，并且返回队列中未执行的任务
List<Runnable> shutdownNow()
//新任务拒绝策略,注意：它们都是RejectedExecutionHandler接口的实现类，因此可以直接创建对象，即为接口的实现类对象
//丢弃任务并且抛出异常RejectedExecutionException，是默认的策略
ThreadPoolExecutor.AborrtPolicy
//直接丢弃任务，不给出任何提示，不推荐
ThreadPoolExecutor.DiscardPolicy
//丢弃队列当中等待最久的任务，然后把当前任务加到队列当中去
ThreadPoolExecutor.DiscardOldestPolicy
//由主线程负责调用任务的run()方法，从而绕过线程池直接执行。即主线程直接执行任务
ThreadPoolExecutor.CallerRunPolicy
代码演示：
主程序代码：
package CreateThreadPool;
import java.util.concurrent.*;
/**
* 创建线程池：java当中ExecutorService代表线程池，是一个接口，因此可以通过它的实现类
* ThreadPoolExecutor来创建线程池对象
*
*/
public class CreatePoolDemo1 {
public static void main(String[] args) {
// int corePoolSize,
// int maximumPoolSize,
// long keepAliveTime,
// TimeUnit unit,
// BlockingQueue<Runnable> workQueue,
// ThreadFactory threadFactory,
// RejectedExecutionHandler handler) {
//创建一个线程池对象
ExecutorService es = new ThreadPoolExecutor(3,5,10,TimeUnit.SECONDS,
new ArrayBlockingQueue<>(4),Thread::new,new ThreadPoolExecutor.CallerRunsPolicy());
//创建Runnable的实现类对象，代表Runnable对象，采用多态的写法
Runnable ru = new MyRunnable();
//调用线程对象的execute方法执行Runnable任务。
es.execute(ru);//自动创建新线程，自动处理任务，自动执行。
es.execute(ru);//自动创建新线程，自动处理任务，自动执行。
es.execute(ru);//自动创建新线程，自动处理任务，自动执行。
//由于线程池只有三个核心线程，因此之后会复用这些线程，新任务会进入任务队列缓存起来，等待核心线程处理完之后处理。
//并且当核心线程都在忙，且任务队列也满了的话，会创建临时线程
es.execute(ru);
es.execute(ru);
es.execute(ru);
es.execute(ru);
//此时如果核心线程都在忙的话，就会创建临时线程
es.execute(ru);
es.execute(ru);
//到了拒绝任务的时候了，3个核心线程和2个临时线程都在忙，并且任务队列也满了，根据设置的任务拒绝策略进行
// 相应的处理。
es.execute(ru);
//调用shutdown方法，当线程池所有的任务执行完之后会关闭线程池
// es.shutdown();
}
}
//Runnable类代码
package CreateThreadPool;
public class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()
+"正在执行~");
try {
//调用Thread类的sleep()方法，让当前线程进行休眠
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
（四）线程池处理Callable任务
代码演示：
package CreateThreadPool;
import java.util.concurrent.*;
/**
* 创建线程池：java当中ExecutorService代表线程池，是一个接口，是不能直接实例化的，因此可以通过它的实现类
* ThreadPoolExecutor来创建对象代表线程池对象
*
*/
public class CreatePoolDemo1 {
public static void main(String[] args) throws Exception{
// int corePoolSize,
// int maximumPoolSize,
// long keepAliveTime,
// TimeUnit unit,
// BlockingQueue<Runnable> workQueue,
// ThreadFactory threadFactory,
// RejectedExecutionHandler handler) {
//创建一个线程池对象
// ExecutorService es = new ThreadPoolExecutor(3,5,10,TimeUnit.SECONDS,
// new ArrayBlockingQueue<>(4),Thread::new,new ThreadPoolExecutor.CallerRunsPolicy());
ExecutorService es = new ThreadPoolExecutor(3,5,5,TimeUnit.SECONDS,
new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());
//线程池处理Callable任务,调用线程对象的submit方法,返回未来任务对象，然后调用get方法可以获取线程处理的结果
//调用submit方法，执行Callable任务，创建新线程，自动执行
Future<String> s1 = es.submit(new MyCallable(100));
//调用submit方法，执行Callable任务，创建新线程，自动执行
Future<String> s2 = es.submit(new MyCallable(200));
//调用submit方法，执行Callable任务，创建新线程，自动执行，返回未来任务对象
Future<String> s3 = es.submit(new MyCallable(300));
//复用核心线程，
Future<String> s4 = es.submit(new MyCallable(400));
//调用未来任务对象的get方法获取线程执行的结果
System.out.println(s1.get());
System.out.println(s2.get());
System.out.println(s3.get());
System.out.println(s4.get());
}
}
九 并发 并行
（一）什么是进程
进程就是正在运行的程序(软件)。线程是属于进程的，一个进程当中可以同时运行多个线程。进程中的多个线程其实就是并发和并行的。
(二) 什么是并发
进程中的线程是由CPU负责调度执行的，但是CPU能够同时处理的线程的数量是有限的，为了保证全部线程都能往前执行，CPU会轮回地进行切换，由于CPU切换的速度比较快，给我们的感觉就是好像这些线程在同时执行，这就是并发。
（三）什么是并行
并行就是在同一时刻上，同时有多个线程在被CPU调度执行。
多线程就是并发和并行同时进行的。
十 线程的生命周期
线程的生命周期就是线程从生到死的过程中，经理的各种状态及其状态转换。
java线程的状态一共有六种：这六种状态都定义在Thread类的内部枚举类state类中。分别为NEW(新建)状态 RUNNABLE(可运行)状态 BLOCKED(阻塞)状态 WAITING(无限等待)状态 TIMED_WAINTING(计时等待)状态 TERMINATED(终止)状态
线程的六种状态总结：
1. NEW(新建状态)：线程刚被创建，但是并未启动
2. Runnable(可运行状态)：线程已经调用了start()方法，等待CPU调度
3. Blocked(锁阻塞状态)：线程在执行的时候未竞争到锁对象，该线程进入到Blocked状态
4. Waiting(无限等待状态)：一个线程进入了Waiting状态，另一个线程调用notify或者notifyAll方法才能够唤醒
5. Timed Waiting(计时等待状态)：调用sleep(毫秒)方法和wait(毫秒)方法，进入计时等待状态。
6. Terminated(终止状态)：因为run方法(线程任务方法)正常结束而终止或者因为异常结束run方法而终止。
十一 悲观锁和乐观锁
（一）什么是悲观锁和乐观锁
悲观锁：一上来就加锁，没有安全感，每次只允许一个线程进入访问，访问完毕之后再进行解锁。是线程安全的，但是性能不好。例如假如有100个人同时访问，那么99个人都在排队，处于阻塞状态，只有一个人访问。
乐观锁：一开始不上锁，认为是没有问题的，所有线程一起跑，直到出现线程安全的时候才开始控制，线程是安全的，并且性能比较好，里面采用了一个算法，CompareAndSet算法，一般称为CAS算法。
（二）实战案例：
需求：1个变量，100个线程对其进行操作，每个线程加100次。
代码演示：
//采用悲观锁
//主程序代码
package Thread_case;
/**
* 1个变量，100个线程，每个线程对其加100次。
*
*/
public class ThreadDemo1 {
public static void main(String[] args) {
//创建任务对象
Runnable ru = new MyRunnable();
for(int i=0;i<100;i++)
{
//创建线程对象，封装任务对象，启动线程，启动之后会等待CPU调度执行，执行run方法
new Thread(ru).start();
}
}
}
//任务类代码
package Thread_case;
public class MyRunnable implements Runnable{
private int count;
@Override
public void run() {
for(int i=0;i<100;i++)
{
//将修改共享资源的核心代码块上锁，锁对象为MyRunnable对象
synchronized (this) {
System.out.println(Thread.currentThread().getName()+"-->"+(++count));
}
}
}
}
//采用乐观锁
//主程序代码
package Thread_case;
/**
* 1个变量，100个线程，每个线程对其加100次。
*
*/
public class ThreadDemo1 {
public static void main(String[] args) {
//创建任务对象
Runnable ru = new MyRunnable();
for(int i=0;i<100;i++)
{
//创建线程对象，封装任务对象，启动线程，启动之后会等待CPU调度执行，执行run方法
new Thread(ru).start();
}
}
}
//任务类代码
package Thread_case;
import java.util.concurrent.atomic.AtomicInteger;
public class MyRunnable implements Runnable{
//整数修改的乐观锁：原子类实现的
private AtomicInteger count = new AtomicInteger();
@Override
public void run() {
for(int i=0;i<100;i++)
{
//调用原子类对象的incrementAndGet()方法，将数加1之后再返回
System.out.println(Thread.currentThread().getName()+"-->"+(count.incrementAndGet()));
}
}
}
十二多线程练习题目
（一）卖票
题目描述：现在有三个火车售票窗口，一起卖100张票，请输出每个窗口卖出了多少张票。
思路分析：三个售票窗口分别代表三个线程，100张火车票代表共享资源，因此需要创建一个线程类以及一个火车票类，分别进行实例化。
注意：由于题目要求得出每个窗口卖出了多少张票，因此最好使用实现Callable接口的方式创建线程，因为这种方式可以获得线程执行结束之后的返回值。
代码演示：
// 实体类代码
package com.zisheng.MyThread.Pojo;
/**
* 实体类，代表火车票实体
*/
public class TrainTicket {
private Long total;// 代表火车票的总个数
private Double unitPrice;// 代表火车票的单价
public TrainTicket(){
}
public Long getTotal() {
return total;
}
public void setTotal(Long total) {
this.total = total;
}
public Double getUnitPrice() {
return unitPrice;
}
public void setUnitPrice(Double unitPrice) {
this.unitPrice = unitPrice;
}
public TrainTicket(Long total, Double unitPrice) {
this.total = total;
this.unitPrice = unitPrice;
}
}
// 线程类代码
package com.zisheng.MyThread.ThreadClasses;
import com.zisheng.MyThread.Pojo.TrainTicket;
import java.util.concurrent.Callable;
/**
* 线程类，利用该类创建对象得到三个窗口线程
*/
public class WindowsThread implements Callable<Long> {
private TrainTicket trainTicket;//代表火车票共享资源
private Long count = 0L;//代表每个窗口线程卖出的票数
public WindowsThread(){
}
public WindowsThread(TrainTicket trainTicket)
{
this.trainTicket = trainTicket;
}
public Long call() throws Exception {
String name = Thread.currentThread().getName();//获取当前执行的线程名字
while(true)
{
// 这里使用同步代码块进行加锁，以此来保证线程安全
synchronized (trainTicket)
{
if(trainTicket.getTotal() == 0)
{
System.out.println("火车票已经卖完！！！");
break;
}
trainTicket.setTotal(trainTicket.getTotal() - 1);//火车票总数减一
this.count++;
System.out.println(name + "卖出了一张票");
//卖出票之后休眠一段时间，防止某个窗口全部卖完所有票
Thread.sleep((long) (Math.random() * 10));
}
}
return this.count;
}
}
// 主程序代码：
package com.zisheng.MyThread;
import com.zisheng.MyThread.Pojo.TrainTicket;
import com.zisheng.MyThread.ThreadClasses.WindowsThread;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class TrainTicketDemo {
public static void main(String[] args) throws Exception {
// 创建火车票对象，设置票数作为共享资源。
TrainTicket trainTicket = new TrainTicket(100L,null);
// 创建三个Callable线程对象，传入共享资源，交给三个线程进行处理
Callable<Long> callable1 = new WindowsThread(trainTicket);
Callable<Long> callable2 = new WindowsThread(trainTicket);
Callable<Long> callable3 = new WindowsThread(trainTicket);
// 将三个Callable线程对象封装成线程任务对象
FutureTask<Long> futureTask1 = new FutureTask<>(callable1);
FutureTask<Long> futureTask2 = new FutureTask<>(callable2);
FutureTask<Long> futureTask3 = new FutureTask<>(callable3);
// 创建Thread线程对象，封装任务对象，指定线程的名称，调用start方法启动线程
new Thread(futureTask1,"一号售票口").start();
new Thread(futureTask2,"二号售票口").start();
new Thread(futureTask3,"三号售票口").start();
// 调用线程任务对象的get方法获取线程返回的结果，
// 注意：这里是一定能获得返回的结果的，如果当前线程未执行完
// 那么主线程就会暂停，直到获取到结果之后再开始执行
Long count1 = futureTask1.get();
Long count2 = futureTask2.get();
Long count3 = futureTask3.get();
System.out.println("一号售票口卖出了" + count1 + "票");
System.out.println("二号售票口卖出了" + count2 + "票");
System.out.println("三号售票口卖出了" + count3 + "票");
}
}
程序执行结果：
（二）分发礼物
需求：有100个礼物，小明线程和小红要同时进行分发礼物，当礼物个数小于10的时候，停止分发，输出两个人分别发了多少个礼物。
代码演示：
//主程序代码
package com.zisheng.MyThread;
import com.zisheng.MyThread.ThreadClasses.distributeCallable;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class GiftDemo {
public static List<String> gifts = new ArrayList<>();
public static String[] thing = {"剃须刀","水乳","香水","篮球鞋","洗面奶"};
public static void main(String[] args) throws Exception
{
Random random = new Random();
for(int i = 0;i < 100;i ++) gifts.add(thing[random.nextInt(thing.length)]);
// gifts.forEach(System.out::println);
Callable<Integer> callable1 = new distributeCallable(gifts);
Callable<Integer> callable2 = new distributeCallable(gifts);
FutureTask<Integer> futureTask1 = new FutureTask<>(callable1);
FutureTask<Integer> futureTask2 = new FutureTask<>(callable2);
Thread thread1 = new Thread(futureTask1,"小明");
thread1.start();
Thread thread2 = new Thread(futureTask2,"小红");
thread2.start();
Integer count1 = futureTask1.get();
Integer count2 = futureTask2.get();
System.out.println(thread1.getName() + "卖出了" + count1 + "个礼物");
System.out.println(thread2.getName() + "卖出了" + count2 + "个礼物");
}
}
//线程类代码
package com.zisheng.MyThread.ThreadClasses;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
public class distributeCallable implements Callable<Integer> {
// 代表贡献资源
private List<String> gifts;
// 代表每个线程所分发的礼物数目
private Integer count = 0;
public distributeCallable(){
}
public distributeCallable(List<String> gifts)
{
this.gifts = gifts;
}
@Override
public Integer call() throws Exception {
Random random = new Random();
String threadName = Thread.currentThread().getName();
// 在这里循环要放在锁外面的，因为如果放在锁里面，那么就只有一个线程进去
// 也就只有一个人把礼物发完了
while(true)
{
// 加锁。注意：在这里不能采用this作为锁对象，因为在这里是创建了两个线程对象，this不是唯一的
// 因为两个线程对象共用一个集合对象，因此可以采用集合对象当成锁对象
synchronized (gifts)
{
if(gifts.size() < 10)
{
System.out.println("礼物的数目剩余" + gifts.size() + "个" + ",分发结束");
break;
}
String giftName = gifts.remove(random.nextInt(gifts.size()));
this.count++;
System.out.println(threadName + "卖出了一个" + giftName);
// 发出一个礼物之后，让该线程休眠一段时间
Thread.sleep((long) (Math.random() * 10));
}
}
return this.count;
}
}
执行结果如下图：
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
