多线程
线程其实是程序中的一条执行路径
我之前所以写的程序，其实都是单线程程序
那么怎样的程序才是多线程程序呢？
- 支持同时有很多人一起进入网站，并且每一个人的行为互不影响。例如百度网盘中，可以同时上传或者下载的多个文件，这些程序中其实就有多条执行路径，每一个执行路径就是一条线程，这样的程序就是多线程程序
线程创建方式
线程创建方式 (继承Threa)
Java为开发者提供了一个类叫做Thread，此类的对象用来表示线程。
- 定义一个子类继承Thread类，并重写run()方法
- 创建thread的子类对象
- 调用statr方法启动线程(启动线程后，会自动执行run方法中的代码)
代码如下
public class MyThread extends Thread{
// 2、必须重写Thread类的run方法
@Override
public void run() {
// 描述线程的执行任务。
for (int i = 1; i <= 5; i++) {
System.out.println("子线程MyThread输出：" + i);
}
}
}
再定义一个测试类，在测试类中创建MyThread线程对象，并启动线程
public class ThreadTest1 {
// main方法是由一条默认的主线程负责执行。
public static void main(String[] args) {
// 3、创建MyThread线程类的对象代表一个线程
Thread t = new MyThread();
// 4、启动线程（自动执行run方法的）
t.start();
for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出：" + i);
}
}
}
在每次打印的时候会发现
MyThread和main线程在相互抢夺cpu的执行权
子线程MyThread输出：1
子线程MyThread输出：2
主线程main输出:1
子线程MyThread输出：3
主线程main输出：2
线程创建方式(实现Runnable接口)
Java为开发者提供了一个Runnable接口，该接口只有一个run方法,意思就是通过Runnable接口，接口中只有一个run方法，通过Runnable接口的实现类对象专门来表示线程来执行的任务
- 先写一个Runnable接口的实现类，重写run方法(这里面就是线程要执行的代码)
- 再创建一个Runnable实现类的对象
- 创建一个Thread对象，把Runnable实现类的对象传递给Thread
- 调用Thread对象的statr()方法启动线程(启动后会自动执行Runnable里面的run方法)
代码如下:
/**
* 1、定义一个任务类，实现Runnable接口
*/
public class MyRunnable implements Runnable{
// 2、重写runnable的run方法
@Override
public void run() {
// 线程要执行的任务。
for (int i = 1; i <= 5; i++) {
System.out.println("子线程输出 ===》" + i);
}
}
}
再写一个测试类,在测试类中创建线程对象，并执行线程
public class ThreadTest2 {
public static void main(String[] args) {
// 3、创建任务对象。
Runnable target = new MyRunnable();
// 4、把任务对象交给一个线程对象处理。
// public Thread(Runnable target)
new Thread(target).start();
for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出 ===》" + i);
}
}
}
结果如下
注意：没有出现下面交替执行的效果也是正常的
主线程main输出 ===》1
主线程main输出 ===》2
主线程main输出 ===》3
子线程输出 ===》1
子线程输出 ===》2
子线程输出 ===》3
子线程输出 ===》4
子线程输出 ===》5
主线程main输出 ===》4
主线程main输出 ===》5
线程创建方法(匿名内部类)
实际上是对于第二种，接口方式的改进
不写Runnable实现类，于是可以直接创建Runnable接口的匿名内部类对象，传递给Thread对象
代码如下
public class ThreadTest2_2 {
public static void main(String[] args) {
// 1、直接创建Runnable接口的匿名内部类形式（任务对象）
Runnable target = new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程1输出：" + i);
}
}
};
new Thread(target).start();
// 简化形式1：
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程2输出：" + i);
}
}
}).start();
// 简化形式2：
new Thread(() -> {
for (int i = 1; i <= 5; i++) {
System.out.println("子线程3输出：" + i);
}
}).start();
for (int i = 1; i <= 5; i++) {
System.out.println("主线程main输出：" + i);
}
}
}
线程创建方式 (run方法有返回结果)
以上几种创建方式，重写的run方法均没有返回结果。
- JDK5提供了Callable接口和FutureTask类来创建线程，它最大的优点就是有返回值
- 在Callable接口中有一个cakk方法，重写call方法就是线程要执行的代码，它是有返回值的
public T call(){
...线程执行的代码...
return 结果;
}
创建线程步骤如下
- 先定义一个Callable接口的实现类，重写call方法
- 创建Callable实现类的对象
- 创建FutureTask类的对象，将Callable对象传递给FutureTask
- 创建Thread对象，将Future对象传递给Thread
- 调用Thread的start()方法启动线程，（启动后会自动执行call方法）等call（）方法执行之后，会自动将返回值结果封装到FutrueTask对象中
- 调用FutrueTask对的get()方法获取返回结果
代码如下
/**
* 1、让子类继承Thread线程类。
*/
public class MyThread extends Thread{
// 2、必须重写Thread类的run方法
@Override
public void run() {
// 描述线程的执行任务。
for (int i = 1; i <= 5; i++) {
System.out.println("子线程MyThread输出：" + i);
}
}
}
在定义一个测试类，在测试类中创建线程并启动线程，还要获取返回结果
public class ThreadTest3 {
public static void main(String[] args) throws Exception {
// 3、创建一个Callable的对象
Callable<String> call = new MyCallable(100);
// 4、把Callable的对象封装成一个FutureTask对象（任务对象）
// 未来任务对象的作用？
// 1、是一个任务对象，实现了Runnable对象.
// 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果。
FutureTask<String> f1 = new FutureTask<>(call);
// 5、把任务对象交给一个Thread对象
new Thread(f1).start();
Callable<String> call2 = new MyCallable(200);
FutureTask<String> f2 = new FutureTask<>(call2);
new Thread(f2).start();
// 6、获取线程执行完毕后返回的结果。
// 注意：如果执行到这儿，假如上面的线程还没有执行完毕
// 这里的代码会暂停，等待上面线程执行完毕后才会获取结果。
String rs = f1.get();
System.out.println(rs);
String rs2 = f2.get();
System.out.println(rs2);
}
}
多线程常用方法
话不多说，直接上代码
public class MyThread extends Thread{
public MyThread(String name){
super(name); //1.执行父类Thread(String name)构造器，为当前线程设置名字了
}
@Override
public void run() {
//2.currentThread() 哪个线程执行它，它就会得到哪个线程对象。
Thread t = Thread.currentThread();
for (int i = 1; i <= 3; i++) {
//3.getName() 获取线程名称
System.out.println(t.getName() + "输出：" + i);
}
}
}
在测试类中，创建线程对象，并启动线程
public class ThreadTest1 {
public static void main(String[] args) {
Thread t1 = new MyThread();
t1.setName(String name) //设置线程名称;
t1.start();
System.out.println(t1.getName()); //Thread-0
Thread t2 = new MyThread("2号线程");
// t2.setName("2号线程");
t2.start();
System.out.println(t2.getName()); // Thread-1
// 主线程对象的名字
// 哪个线程执行它，它就会得到哪个线程对象。
Thread m = Thread.currentThread();
m.setName("最牛的线程");
System.out.println(m.getName()); // main
for (int i = 1; i <= 5; i++) {
System.out.println(m.getName() + "线程输出：" + i);
}
}
}
在执行结果中，我们会发现每一条线程都会有自己的名字
join()方法可以让这个方法的线程优先执行完
public class ThreadTest2 { public static void main(String[] args) throws Exception { // join方法作用：让当前调用这个方法的线程先执行完。 Thread t1 = new MyThread("1号线程"); t1.start(); t1.join(); Thread t2 = new MyThread("2号线程"); t2.start(); t2.join(); Thread t3 = new MyThread("3号线程"); t3.start(); t3.join(); }}
线程安全问题
线程安全问题是使用线程时最重要的一个问题。
线程安全问题概述
- 那么什么叫线程安全问题呢
线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题
案例
场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？
小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的
① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。
② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。
③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。
④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。
由此体现了线程安全问题的一种体现
线程同步方案
为了解决线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能加锁进来
那么采用加锁的方案，就可以解决前面两个线程都进入取钱的问题，怎么加锁呢？
Java提供了三种解决方案
1.同步代码块
2.同步方法
3.LocK锁
同步代码块
同步代码块的作用就是把访问共享数据的代码锁起来，以此保证线程安全
//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
//...访问共享数据的代码...
}
使用同步代码块，来解决前面代码里面的线程安全问题，我们只需要修改DrawThread类中的代码即可
// 小明 小红线程同时过来的
public void drawMoney(double money) {
// 先搞清楚是谁来取钱？
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
// 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作为锁对象
- 对于静态方法，建议把类的字节码(类名.class)当作锁对象
同步方法
同步 方法，也可以用来解决线程安全问题，其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。
// 同步方法
public synchronized void drawMoney(double money) {
// 先搞清楚是谁来取钱？
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功！");
this.money -= money;
System.out.println(name + "来取钱后，余额剩余：" + this.money);
}else {
System.out.println(name + "来取钱：余额不足~");
}
}
同步方法也有锁对象
同步对象也有锁对象，但是这个锁对象没有显示的写出来而已
- 对于实例方法，锁对象其实是this（也就是方法的调用者）
- 对于静态方法，锁对象时类的字节码对象（类名.class）
那么同步代码块和同步方法有什么区别?
- 不存在哪个好与不好，只是一个锁住的范围大，一个范围小
- 同步方法是将方法中所有的代码锁住
- 同步代码块是将方法中的部分代码锁住
Lock锁
Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁和释放锁的目的，使用起来更加灵活。
1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
lk.lock(); // 加锁
//...中间是被锁住的代码...
lk.unlock(); // 解锁
使用Lock锁改写前面DrawThread中取钱的方法，代码如下
// 创建了一个锁对象
private final Lock lk = new ReentrantLock();
public void drawMoney(double money) {
// 先搞清楚是谁来取钱？
String name = Thread.currentThread().getName();
try {
lk.lock(); // 加锁
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name + "来取钱" + money + "成功！");
this.money -= money;
System.out.println(name + "来取钱后，余额剩余：" + this.money);
}else {
System.out.println(name + "来取钱：余额不足~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lk.unlock(); // 解锁
}
}
}
线程通信（包子案例）
什么是线程通信呢？
-
当多个线程共同操作共享资源时，线程间通过某种方法互相告知自己的状态，以相互协调，避免无效的资源争取
线程通信的常见模式：是生存者与消费者模型
-
生产者线程负责生成数据
-
消费者线程负责消费生产者生成的数据
-
注意：生产者生产完数据之后应该让自己等待，通知其他消费者消费，消费者消费完数据之后应该让自己等待，同时通知生产者生成
比如包子案例（有三个厨师（生产者线程），两个顾客（消费者线程））.
分析
先确定在这个案例中什么是共享数据
这里案例中吃饭的桌子是共享数据，因为顾客和厨师都需要对桌子上的包子进行操作
再确定线程问题
厨师是生产者线程，3条生产者线程
顾客是消费者线程，2条消费者线程
什么时候将哪一个线程设置为什么状态
生产者线程（厨师）放包子：
- 首先判断是否有包子
- 没有包子时，厨师开始做包子，做完之后把别人唤醒，然后让自己等待
- 有包子时，不做包子了，直接唤醒别人，然后让自己等待
消费者线程（顾客）吃包子：
- 先判断是否有包子
- 有包子时，顾客开始吃包子，吃完之后把别人唤醒，然后让自己等待
- 没有包子时，不吃包子了，直接唤醒别人，然后让自己等待
按照以上分析思路写代码.先写桌子类
public class Desk {
private List<String> list = new ArrayList<>();
// 放1个包子的方法
// 厨师1 厨师2 厨师3
public synchronized void put() {
try {
String name = Thread.currentThread().getName();
// 判断是否有包子。
if(list.size() == 0){
list.add(name + "做的肉包子");
System.out.println(name + "做了一个肉包子~~");
Thread.sleep(2000);
// 唤醒别人, 等待自己
this.notifyAll();
this.wait();
}else {
// 有包子了，不做了。
// 唤醒别人, 等待自己
//通知当前对象的所有等待线程
this.notifyAll();
//他会被暂停，直到其他线程调用notify()或者notifyAll()方法通知它继续执行
this.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}
// 吃货1 吃货2
public synchronized void get() {
try {
String name = Thread.currentThread().getName();
if(list.size() == 1){
// 有包子，吃了
System.out.println(name + "吃了：" + list.get(0));
list.clear();
Thread.sleep(1000);
this.notifyAll();
this.wait();
}else {
// 没有包子
this.notifyAll();
this.wait();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
再写测试类，在测试类中，创建3个厨师线程对象，再创建2个顾客对象，并启动所有线程
public class ThreadTest {
public static void main(String[] args) {
// 需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上
// 2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃。
Desk desk = new Desk();
// 创建3个生产者线程（3个厨师）
new Thread(() -> {
while (true) {
desk.put();
}
}, "厨师1").start();
new Thread(() -> {
while (true) {
desk.put();
}
}, "厨师2").start();
new Thread(() -> {
while (true) {
desk.put();
}
}, "厨师3").start();
// 创建2个消费者线程（2个吃货）
new Thread(() -> {
while (true) {
desk.get();
}
}, "吃货1").start();
new Thread(() -> {
while (true) {
desk.get();
}
}, "吃货2").start();
}
}
线程池
线性池概述
应用发起请求每次进来之后就要创建一个新线程，浪费资源
线程池就是一个可以复用线程的技术
线性池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这三个核心线程可以处理3个任务。但是任务总有被执行完的时候，假设第一个线程的任务执行完了，那么第一个线程就空闲下来了。有新的任务，空闲的第一个线程可以去执行其他任务。依次内推，这三个线程可以不断的复用，也可以执行很多个任务
线性池可以提高线程的利用率
创建线程池
在JDK5版本中提供了代表线程池的接口ExecutorService，而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象
ExecutorService pool = new ThreadPoolExecutor(
3, //核心线程数有3个
5, //最大线程数有5个。 临时线程数=最大线程数-核心线程数=5-3=2
8, //临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
TimeUnit.SECONDS,//时间单位（秒）
new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
Executors.defaultThreadFactory(), //用于创建线程的工厂对象
new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);
关于线程池，我们是需要注意以下两个问题
-
临时线程什么时候创建？
新任务提交时，发现核心线程都在忙，任务队列满了，并且还可以创建临时线程。此时会创建临时线程
-
什么时候开始拒绝新的任务？
核心线程和临时线程都在忙，任务队列也满了，新任务过来时才会开始拒绝任务
线程池执行Runnable任务
线程池执行的任务可以有两种：一种是Runnable任务，另一种是callable任务，下面的execute方法可以用来执行Runnable任务
先准备一个线程任务类
public class MyRunnable implements Runnable{
@Override
public void run() {
// 任务是干啥的？
System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");
//为了模拟线程一直在执行，这里睡久一点
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解
ExecutorService pool = new ThreadPoolExecutor(
3, //核心线程数有3个
5, //最大线程数有5个。 临时线程数=最大线程数-核心线程数=5-3=2
8, //临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
TimeUnit.SECONDS,//时间单位（秒）
new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
Executors.defaultThreadFactory(), //用于创建线程的工厂对象
new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);
Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
//下面4个任务在任务队列里排队
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);
//下面2个任务，会被临时线程的创建时机了
pool.execute(target);
pool.execute(target);
// 到了新任务的拒绝时机了！
pool.execute(target);
线程池执行Callable任务
执行Callable任务需要用到submit方法
先准备一个Callable线程任务
public class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n) {
this.n = n;
}
// 2、重写call方法
@Override
public String call() throws Exception {
// 描述线程的任务，返回线程执行返回后的结果。
// 需求：求1-n的和返回。
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
}
}
再准备一个测试类，在测试类中创建线程池，并执行callable任务
public class ThreadPoolTest2 {
public static void main(String[] args) throws Exception {
// 1、通过ThreadPoolExecutor创建一个线程池对象。
ExecutorService pool = new ThreadPoolExecutor(
3,
5,
8,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
// 2、使用线程处理Callable任务。
Future<String> f1 = pool.submit(new MyCallable(100));
Future<String> f2 = pool.submit(new MyCallable(200));
Future<String> f3 = pool.submit(new MyCallable(300));
Future<String> f4 = pool.submit(new MyCallable(400));
// 3、执行完Callable任务后，需要获取返回结果。
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
}
}
线程池工具类(Executors)
创建线程池的代码参数太多了，所以为了Java为开发者提供了一个创建线程池的工具类，叫做Executors，它提供了方法可以创建各种不同特点的线程池
创建固定线程数量的线程池。
public class ThreadPoolTest3 {
public static void main(String[] args) throws Exception {
// 1、通过Executors创建一个线程池对象。
ExecutorService pool = Executors.newFixedThreadPool(17);
// 老师：核心线程数量到底配置多少呢？？？
// 计算密集型的任务：核心线程数量 = CPU的核数 + 1
// IO密集型的任务：核心线程数量 = CPU核数 * 2
// 2、使用线程处理Callable任务。
Future<String> f1 = pool.submit(new MyCallable(100));
Future<String> f2 = pool.submit(new MyCallable(200));
Future<String> f3 = pool.submit(new MyCallable(300));
Future<String> f4 = pool.submit(new MyCallable(400));
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
}
}
补充知识
并发和并行
- 正常运行的程序就是一个独立的进程
- 线程是属于进程，一个进程中包含多个线程
- 进程中的线程其实并发和并行同时存在
首先，来学习一下什么是并发？
进程中的线程由CPU负责调度执行，但是CPU同时处理线程的数量是优先的，为了保证全部线程都能执行到，CPU采用轮询机制为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。（简单记：并发就是多条线程交替执行）
接下，再来学习一下什么是并行？
并行指的是，多个线程同时被CPU调度执行。如下图所示，多个CPU核心在执行多条线程
标签：执行,Thread,对象,线程,new,多线程,public From： https://www.cnblogs.com/yifan0820/p/17854915.html