Java-多线程
线程
要想学习多线程，就得先知道什么是线程，要想知道线程，就得先知道什么是进程。
- 进程：
是指正在运行的程序，是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和资源。
通过任务管理器看- 线程：
是进程的单个顺序控制流，或者就是说是一个单独执行的路径
如果一个进程只有一条执行路径，称之为单线程
如果一个进程有多条执行路径，称之为多线程
线程是包含在进程中的。
举例：扫雷，360杀毒软件，百度网盘
何为串行，并行，并发？
- 1、串行,是指一个程序中所有的任务都是按照先后顺序执行的，在前一个任务还没有处理完的情况下，是不会进行处理下一个任务的。
举例：理发店只有一个理发师，很多人去理发，就需要排队，就有先后顺序，先等前面的人理完发，再轮到后面的人。- 2、并行,是指将任务分给不同的处理器去畜栏里，每一个处理器中的任务再进行串行处理
举例：火车站上有很多卖票窗口，多个窗口同时卖票，但是呢，针对于某一个窗口来说，是一个接着一个去处理的。- 3、并发,是指一个现象，并发需要处理器的支持，比如在处理一个任务的时候，操作系统可以调用资源去处理其他的任务，这个任务并行还是串行都可以
无论是串行还是并行，都需要处理支持并发。
举例：假设喝水是一个任务，每个火车站售票员，他再售票的同时也能喝水，这就表示支持并发
思考?JVM启动的时候是单线程还是多线程呢？多线程
- JVM启动的时候，相当于启动了一个程序，就是启动了一个进程
其中包含了主线程，垃圾回收线程。
在启动JVM的时候，最低的要求是需要启动两个线程，所以JVM启动的时候是多线程程序。
创建线程的第一种方式：继承Thread类，重写run方法
- 1、创建一个自定义类继承Thread类
- 2、这个继承的类要重写run方法
1）为什么要重写run方法？
2）重写run方法后如何使用？- 3、根据这个类创建线程对象
- 4、启动线程
面试题：线程调用start()和run()方法的区别？
- 单纯地调用run方法仅仅表示的是第一个对象调用普通的方法，所以这里的执行还是按照自上而下顺序执行，所以这里依旧是单线程程序
要想看到多线程程序的执行效果，就必须换一种方式启动线程。start()
run方法中仅仅是封装了被线程执行的逻辑代码，但是直接对象调用run方法于普通的方法调用没有任何区别
start()方法调用，首先做的是启动一个线程，然后再由JVM去调用该线程对象中的run()方法
模拟多线程环境
- 要想模拟多线程环境，就得创建多个线程对象，然后同时启动
模拟多线程环境，至少创建2个及以上的线程对象
注意事项
- 1、启动线程调用的是start()方法
- 2、线程的调用start()方法先后顺序与今后真正执行的顺序没有影响
线程的逻辑代码
package com.shujia.wyh.day25;
public class MyThread1 extends Thread{
@Override
public void run() {
//写的是线程要执行的逻辑代码
// System.out.println("数加真好！");
//一般情况下，线程执行的逻辑代码都是比较耗时并且复杂的，为了模拟这里耗时复杂，我使用循环打印来代替
for(int i=1;i<=300;i++){
System.out.println(i);
}
}
}
Thread类的基本获取和设置方法
1.设置名字（两种方法）
- 1、public final void setName(String name)
- 2、通过构造方法给线程起名字Thread(String name)
获取名字
- 如何获取一个线程的名字呢？
public final String getName()
public class MyThreadDemo3 {
public static void main(String[] args) {
// MyThread2 t1 = new MyThread2(); //Thread-0
// MyThread2 t2 = new MyThread2(); //Thread-1
MyThread2 t1 = new MyThread2("李毅");
MyThread2 t2 = new MyThread2("小虎");
// t1.setName("李毅");
// t2.setName("小虎");
//启动线程
t1.start();
t2.start();
}
}
线程调度问题
问题引入
- 假如我们的计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到 CPU时间片，也就是使用权，
才可以执行指令。那么Java是如何对线程进行调用的呢？
线程的两种调度模型(Java属于抢占式调度模型)
- 1、分时调度模型 所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
- 2、抢占式调度模型 优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，
Java使用的是抢占式调度模型。***
获取线程中的优先级方法：
public final int getPriority() 返回此线程的优先级。
设置线程优先级的方法：
- public final void setPriority(int newPriority) 更改此线程的优先级。
最大和最小优先级
public final static int MIN_PRIORITY = 1; 线程可以拥有的最小的优先级
public final static int MAX_PRIORITY = 10; 线程可以拥有的最大的优先级
注意事项：
- 1、线程的默认优先级是5
- 2、设置优先级的时候，范围是1-10
- 3、线程的优先级越高仅仅表示的是获取CPU时间片的机率会高一些，并不能保证一定会先执行。
代码如下：
public class ThreadPriorityDemo {
public static void main(String[] args) {
MyPriorityThread p1 = new MyPriorityThread();
MyPriorityThread p2 = new MyPriorityThread();
MyPriorityThread p3 = new MyPriorityThread();
//获取线程优先级
// int py1 = p1.getPriority();
// System.out.println(py1); 5
// int py2 = p2.getPriority();
// System.out.println(py2); 5
// int py3 = p3.getPriority();
// System.out.println(py3); 5
//可以设置线程的优先级
p1.setPriority(10);
p2.setPriority(5);
p3.setPriority(1);
//设置各个线程的名字
p1.setName("小花");
p2.setName("小黑");
p3.setName("小白");
p1.start();
p2.start();
p3.start();
}
}
线程加入 public final void join()
- public final void join()
线程对象调用该方法的时候，目的是让调用该方法的当前线程先执行完，执行完毕后，再让其他线程执行
其他没有调用join方法的线程，他们之间还是会抢CPU执行权的。
注意事项：
- join方法的调用，必须是紧跟着当前线程start()方法后调用，否则不起作用。
public class JoinDemo {
public static void main(String[] args) {
MyJoinThread jd1 = new MyJoinThread();
MyJoinThread jd2 = new MyJoinThread();
MyJoinThread jd3 = new MyJoinThread();
//给各个线程取名字
jd1.setName("无敌小可爱");
jd2.setName("无敌菠萝怪");
jd3.setName("无敌香蕉π");
//注意：join 方法的调用，必须是紧跟着当前线程start（）方法后调用的，否则不起作用；
//启动各个线程
// try {
// jd1.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
jd1.start();
try {
jd1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
jd2.start();
jd3.start();
}
}
线程礼让 public static void yield()
- 礼让线程的目的是暂停当前正在执行的线程，并让其他线程执行，
它的作用实际上是为了让线程之间看起来更加和谐，它并不能保证多个线程之间一人一次。
public class MyYieldDemo {
public static void main(String[] args) {
//创建多线程环境
MyYieldThread t1 = new MyYieldThread();
MyYieldThread t2 = new MyYieldThread();
MyYieldThread t3 = new MyYieldThread();
//给线程设置名字
t1.setName("小白");
t2.setName("小黑");
t3.setName("小红");
t1.start();
t2.start();
t3.start();
}
}
后台线程(守护线程) public final void setDaemon(boolean on)
线程分类
- 用户线程：我们在学习线程之前，运行起来的一个一个程序中的线程都是用户线程
- 守护线程：所谓的守护线程，指的是程序运行的时候，在后台提供了一个通用的服务线程，比如说垃圾回收线程，他就是一个守护线程。
这种线程不一定是要存在的，但是可能程序会出问题。只要程序存在用户线程，程序就不会停止
守护线程的设置：
- public final void setDaemon(boolean on)
注意事项：
- 1、守护线程必须在启动之前进行设置
public class ThreadDaemonDemo {
public static void main(String[] args) {
//模拟多线程环境
MyDaemonThread dd1 = new MyDaemonThread();
MyDaemonThread dd2 = new MyDaemonThread();
MyDaemonThread dd3 = new MyDaemonThread();
//给线程付名字
// dd1.setName("草莓");
// dd1.setDaemon(true);
dd2.setName("西瓜");
dd2.setDaemon(true);
dd3.setName("菠萝");
dd3.setDaemon(true);
//当所有线程都为守护进程时。守护进程会马上死亡，因为它没有需要守护的东西
//当草莓为线程，其他俩是守护线程时，如果草莓进程结束，那么，西瓜和菠萝也会很快调亡
//启动线程
// dd1.start();
dd2.start();
dd3.start();
}
}
休眠线程
- 模拟真实环境，让线程进入休眠状态
package com.bigdat.java.day26;
public class MySleepThread extends Thread{
@Override
public void run() {
for (int i = 0; i <= 300; i++) {
//需求：每打印一次，间隔 1000 毫秒在打印下一个
//public static void sleep(long millis) throws InterruptedException
//史当前正在执行的线程已指定的毫秒数暂停
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName()+":"+i);
}
}
}
package com.bigdat.java.day26;
/*
public static void sleep(long millis)
*/
public class ThreadSleepDemo {
public static void main(String[] args) {
//创建三个进程
MySleepThread st1 = new MySleepThread();
MySleepThread st2 = new MySleepThread();
MySleepThread st3 = new MySleepThread();
//给进程名字
st1.setName("窗口一");
st2.setName("窗口二");
st3.setName("窗口三");
//启动线程
st1.start();
st2.start();
st3.start();
}
}
中断线程
- 在自定义类中定义每个线程睡眠5秒
public class MyStopTread extends Thread{
@Override
public void run() {
System.out.println("我开始睡觉。。。。");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("睡醒了。。。");
}
}
- 然后再测试类中，将正在睡眠的线程唤醒，即打断线程的休眠时间
两种方法
- public final void stop()
强制打断睡眠，程序停止，这个方法不太好，这个方法已经被弃用
- public void interrupt()/打断睡眠，提示打断睡眠的错误，run方法中后面的代码继续执行，直到执行完毕
public class ThreadStopDemo {
public static void main(String[] args) {
MyStopTread myStopTread = new MyStopTread();
myStopTread.start();
try {
Thread.sleep(2000);
// myStopTread.stop(); //强制打断睡眠，程序停止，这个方法不太好，这个方法已经被弃用
myStopTread.interrupt(); //打断睡眠，提示打断睡眠的错误，run方法中后面的代码继续执行，直到执行完毕。
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
多线程的第二种打开方式-runnable
多线程的实现方式2：实现Runnable接口，实现run方法
- 1、自定义一个类实现Runnable接口
- 2、实现run方法
- 3、创建实现Runnable接口类对应的对象
- 4、借助Thread类创建线程对象，将自定义类作为构造方法的参数传入
主方法代码：
public class MyRunnableDemo1 {
public static void main(String[] args) {
//创建实现Runnable接口类对应的对象
MyRunnable1 myRunnable1 = new MyRunnable1();
//创建多个线程对象
// Thread t1 = new Thread(myRunnable1);
// Thread t2 = new Thread(myRunnable1);
//Thread(Runnable target, String name)
//分配一个新的 Thread对象。
Thread t1 = new Thread(myRunnable1,"小白");
Thread t2 = new Thread(myRunnable1,"小黑");
//给线程起名字
// t1.setName("李毅");
// t2.setName("小虎");
//启动线程
t1.start();
t2.start();
}
}
自定义类代码
public class MyRunnable1 implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 300; i++) {
//由于Runnable接口没有getName()方法，所以在这里无法直接调用获取线程的名字
//间接调用，
//Thread类中有一个静态的方法
// public static Thread currentThread()返回对当前正在执行的线程对象的引用。
// System.out.println(getName() + ":" + i);
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
