线程介绍
-
进程
进程是指运行中的程序，比如使用微信，就启动了一个进程，操作系统将为微信分配内存空间。
进程是程序的一次执行过程，或是正在运行的程序。是动态过程：它有自身的产生、存在和消亡的过程。 -
线程
- 线程是由进程创建的，是进程的一个实体。
- 一个进程可以有多个线程。
单线程和多线程
-
单线程：同一时刻，只允许执行一个线程。
-
多线程：同一时刻，可以执行多个线程。
-
并发：同一时刻，多个任务交替执行（单核CPU实现多任务）
-
并行： 同一时刻，多个任务同时执行（多核CPU可以实现并行）
线程的基本使用
创建线程
- 创建线程的两种方式：
1. 继承Thread类，重写 run 方法
2. 实现Runnable接口，重写 run 方法
继承Thread类
例：
public class Thread01 {
public static void main(String[] args) throws InterruptedException{
//创建cat对象，可以当做线程使用
Cat cat = new Cat();
cat.start();//启动线程
//cat.run();//直接调用run方法，不会开子线程，只有主线程main
//当main线程启动一个子线程 Thread-0，主线程main不会阻塞，会继续执行
System.out.println("主线程继续执行"+Thread.currentThread().getName());
for (int i = 0; i < 10; i++) {
System.out.println("====主线程====");
Thread.sleep(1000);
}
}
}
/*1.当类继承了Thread类时，该类就可以当做线程使用
* 2.重写run方法，写上自己的业务代码
* 3.Thread类 中run方法是实现的Runnable接口的run方法*/
class Cat extends Thread{
int times = 0;
@Override
public void run() {
while (true){
System.out.println("喵喵喵"+(++times)+"线程名："+ Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (times == 3){
break;
}
}
}
}
代码运行过程分析：程序进程包含主线程main和子线程Thread-0，主线程通过start方法开启子线程，如果使用cat.run()调用run方法则不会开启子线程，主线程和子线程在并发执行。
查看Thread类的源代码，会看到start()方法内部调用了一个private native void start0()方法，native修饰符表示这个方法是由JVM虚拟机内部的C代码实现的，不是由Java代码实现的。最终是由start0()方法实现多线程效果。
start()方法调用 start0()方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于 CPU，由 CPU统一调度。
实现Runnable接口
实现Runnable接口，重写 run 方法，没有start方法，所有要先创建Thread对象，把 对象(实现Runnable),放入Thread再调用start方法。
例：
public class Thread02 {
public static void main(String[] args) {
Dog dog = new Dog();
//dog实现Runnable接口是没有start方法的
//创建Thread对象，把 dog对象(实现Runnable),放入Thread
Thread thread = new Thread(dog);
thread.start();//start会启动子线程，调用dog中run方法
}
}
class Dog implements Runnable {
int count = 0;
@Override
public void run() {
while (true) {
System.out.println("汪汪汪" + (++count) + Thread.currentThread().getName());
try {
//休眠1s
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10) {
break;
}
}
}
}
多线程执行
- 继承Thread或者实现Runnable接口的区别
1.从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别,从idk帮助文档我们可以看到Thread类本身就实现了Runnable接口。
2.实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制。
线程终止
线程终止有2种方式：
- 当线程完成任务后，会自动退出。
- 通过使用变量来控制run方法退出的方式停止线程，即通知方式。
通知方式例：
public class Thread04 {
public static void main(String[] args) {
T t1 = new T();
t1.start();
try {
System.out.println("主线程休眠10s...");
Thread.sleep(10 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//修改loop，来通知子线程退出
System.out.println("主线程休眠结束");
t1.setLoop(false);
}
}
class T extends Thread {
private int sum;
//设置一个控制变量
private boolean loop = true;
public void setLoop(boolean loop) {
this.loop = loop;
}
@Override
public void run() {
while (loop) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("======子线程运行中======" + (++sum));
}
}
}
线程常用方法
- setName //设置线程名称，使之与参数 name 相同
- getName //返回该线程的名称
- start //使该线程开始执行; Java 虚拟机底层调用该线程的 start0 方法
- run//调用线程对象 run 方法
- setPriority //更改线程的优先级
- getPriority //获取线程的优先级
线程常用优先级范围：
-
sleep//在指定的毫秒数内让当前正在执行的线程休眠 (暂停执行)
-
interrupt//中断线程，一般用于中断正在休眠的线程
-
yield：让出cpu，让其他线程执行，但礼让的时间不确定，所以也不一定成功
-
join：线程插队。插队的线程一旦插队成功，则肯定先执行完插入的线程任务
-
用户线程与守护线程
- 用户线程：也称工作线程，当线程的任务执行完成或通知方式结束
- 守护线程：一般是为工作线程服务的，当所有的用户线程结束时，守护线程自动结束，常见的守护线程：垃圾回收机制。设置线程为守护线程通过setDaemon方法。
线程的生命周期
JDK中用Thread.State枚举表示了线程的几种状态：
- NEW 尚未启动的线程
- RUNNABLE 在Java虚拟机中执行的线程
- BLOCKED 被阻塞等待监视器锁定的线程
- WAITING 正在等待另一个线程执行特定动作的线程
- TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程
- TERMINATED 已终止的线程
状态流转图：
线程的同步
线程同步机制
- 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
- 线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
同步方法（Synchronized）：
-
同步代码块
synchronized(对象){//得到对象的锁，才能操作同步代码 //需要被同步代码 } -
同步方法
//添加synchronized修饰后，在同一时刻，只能有一个线程来执行该方法 public synchronized void Dome(){}
互斥锁
-
Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
-
每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
-
关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时表明该对象在任一时刻只能由一个线程访问
synchronized(this){//这时锁在当前类对象上 ... } synchronized(demo){//锁也可以加到其他对象上 ... } -
同步的局限性:导致程序的执行效率要降低
-
同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
-
同步方法(静态的)的锁为当前类本身。
class Demo implement Runable{ //下方静态方法的锁加在 Demo.class类 public synchronized static void m() {} } -
同步方法如果没有使用static修饰:默认锁对象为this ；如果方法使用static修饰，默认锁对象:当前类.class
实现的落地步骤：
8. 先分析上锁的代码
9. 选择同步代码块或同步方法
10. 要求多个线程的锁对象为同一个即可
synchronized 例：
//使用3个线程售卖100张票
public class Synchronized_ {
public static void main(String[] args) {
Sell sell = new Sell();
Thread sell01 = new Thread(sell);
Thread sell02 = new Thread(sell);
Thread sell03 = new Thread(sell);
//开启3个卖票线程
sell01.start();
sell02.start();
sell03.start();
}
}
class Sell implements Runnable {
private static int ticketNum = 100;//票数
private boolean loop = true;//线程控制
//添加synchronized修饰后，在同一时刻，只能有一个线程来执行该方法
private synchronized void sell() {
if (ticketNum <= 0) {
System.out.println("售票结束..");
loop = false;
return;
}
System.out.println(Thread.currentThread().getName() + "售票成功," + "剩余票数：" + (--ticketNum));
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void run() {
while (loop) {
sell();
}
}
}
线程的死锁
-
死锁的产生：多个线程都占用了对方的锁资源，但不肯相让，导致死锁，在编程一定要避免死锁的发生
//模拟线程死锁 public class DeadLock_ { public static void main(String[] args) { DeadLockDemo deadLockDemo1 = new DeadLockDemo(true); DeadLockDemo deadLockDemo2 = new DeadLockDemo(false); deadLockDemo1.start(); deadLockDemo2.start(); } } class DeadLockDemo extends Thread{ static Object o1 = new Object(); static Object o2 = new Object(); boolean flag; public DeadLockDemo(boolean flag) { this.flag = flag; } @Override public void run() { //下面业务逻辑的分析 //如果flag 为 T，线程A 就会先得到/持有 01 对象锁，然后尝试去获取 02 对象锁 //如果线程A 得不到 o2 对象锁，就会BLocked //如果flag 为 F，线程B 就会先得到/持有 02 对象锁，然后尝试去获取 01 对象锁 //如果线程B 得不到 o1 对象锁，就会BLocked if (flag){ synchronized (o1){ System.out.println(Thread.currentThread().getName()+"进入1"); synchronized (o2){ System.out.println(Thread.currentThread().getName()+"进入2"); } } }else { synchronized (o2){ System.out.println(Thread.currentThread().getName()+"进入3"); synchronized (o1){ System.out.println(Thread.currentThread().getName()+"进入4"); } } } } }
释放锁
-
会释放锁的操作
- 当前线程的同步方法、同步代码块执行结束
- 当前线程在同步代码块、同步方法中遇到break、return
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()，当前线程暂停，并释放锁
-
不会释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起该线程不会释放锁。
提示:应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
