15.线程
15.1 概念
程序：是为完成特定任务，用某种语言编写的一组指令的集合。
进程：进程就是指运行中的程序。进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程，有它自身的产生、存在和消亡的过程。
线程：线程是由进程创建的，是进程的一个实体，一个进程可以拥有多个线程。
单线程：同一时刻，只允许执行一个线程。
多线程：同一时刻，可以执行多个线程。
并发：同一个时刻，多个任务交替执行，造成一种"貌似同时"的错觉，简单说，单核cpu实现的多任务就是并发。
并行：同一个时刻，多个任务同时执行。多核cpu可以实现并行。
可以使用JConsole监控线程执行情况，在终端使用
15.2 创建线程
java线程结构：
-
继承Thred类，重写 run 方法
Cat继承Thread类并重写run方法，可以创建新线程。在main方法中创建Cat对象，调用start方法就会创建一个新的线程，新的线程执行的是run方法，主线程不会等子线程执行，而是和子线程并发执行
程序具体执行：当run当前main时，就启动一个进程，进程运行main方法，启动一个主线程，一个垃圾回收线程，在main方法中创建Cat(继承Thread)对象，然后调用cat.run方法时，主线程新启动一个子线程，子线程运行不会导致主线程阻塞，主线程继续运行，直到结束，当所有线程都结束后，进程结束，并不是主线程(mian方法)结束进程就结束
package com.edu.threaduse; /** * @author Rain */ public class Thread1 { public static void main(String[] args) { //创建一个Cat对象，可以当做线程使用 Cat cat = new Cat(); //启动线程 cat.start(); //当main线程启动一个子线程Thread-0，主线程不会阻塞 for (int i = 0;i < 50;i++){ System.out.println("主线程继续执行" + Thread.currentThread().getName()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } //当一个类继承了Thread类，该类就可以当做一个线程使用 //通常会重写run方法，写上自己的业务代码 class Cat extends Thread{ @Override public void run() { for (int i = 0;i < 80;i++){ System.out.println("喵喵" + i + "线程名称：" + Thread.currentThread().getName()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }细节：
创建Cat对象后，启动线程是调用 cat.start()方法，不是调用 cat.run()方法。如果调用cat.run()方法，就不会启动新线程，而是调用方法，会阻塞。真正实现启动新线程的是start方法内的 start0 方法。
-
实现Runnable接口，重写 run 方法
java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法去创建线程显然不可能。
java设计者提供了另外一个方式创建线程，就是通过实现Runnable接口去创建线程。
具体实现和上面类似，不过由于实现Runnable接口的Dog类没有start方法，要开启新的线程需要创建一个Thread对象，把Dog类作为参数传入，然后用这个Thread对象开启线程
package com.edu.threaduse; /** * @author Rain */ public class Thread02 { public static void main(String[] args) { //创建一个Dog对象 Dog dog = new Dog(); //创建Thread对象，把dog传入，启动线程 new Thread(dog).start(); //当main线程启动一个子线程Thread-0，主线程不会阻塞 for (int i = 0;i < 10;i++){ System.out.println("主线程继续执行" + Thread.currentThread().getName()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } class Dog implements Runnable{ @Override public void run() { for (int i = 0;i < 10;i++){ System.out.println("汪汪" + i + "线程名称：" + Thread.currentThread().getName()); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
细节：
在第11行执行 new Thread(dog).start(); 代码，解析：Thread类继承了Runnable接口；在源码中，Thread类有一个Runnable属性target，Thread的有参构造器：
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
参数是Runnable，Dog类实现了Runnable接口，dog对象是Dog类的实例，所以可以把dog当作构造器参数创建Thread实例。同时这个过程运用了静态代理模式，简单说：new 一个Thread类，参数dog，然后调用start方法，在start方法中又调用了start0()方法，start0()方法启动新线程，调用run方法，Thread的run方法首先判断属性target是否为空，不为空就调用target的run方法。在构造器初始化时，把dog赋给targe，因为dog对象是Dog类实例，Dog类中重写了run方法，所以会使用动态绑定机制，执行dog对象的run方法。
15.3 线程终止
-
当线程run方法执行完毕后，会自动退出
-
还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式
public class ThreadExit { public static void main(String[] args) { T t = new T(); t.start(); try { Thread.sleep(10000); } catch (InterruptedException e) { e.printStackTrace(); } t.setLoop(false); } } class T extends Thread{ int count = 0; boolean loop = true; public boolean isLoop() { return loop; } public void setLoop(boolean loop) { this.loop = loop; } @Override public void run() { while (loop){ try { Thread.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程还在运行" + ++count); } } }
15.4 线程常用方法
-
setName：设置线程名称，使之与参数name相同
-
getName：返回该线程的名称
-
start：使该线程开始执行；Java虚拟机底层调用该线程的start0方法
-
run：调用线程对象 run 方法
-
setPriority：更改线程的优先级
// Thread.MAX_PRIORITY 10// Thread.MIN_PRIORITY 1// Thread.NORM_PRIORITY 5 -
getPriority：获取线程的优先级
-
sleep：在指定毫秒数内让当前正在执行的线程休眠(暂停执行)，是线程的静态方法
-
interrupt：中断线程，使线程产生InterruptedException异常，可以唤醒sleep的进程
public class ThreadMethod01 { public static void main(String[] args) throws InterruptedException { D d = new D(); d.start(); while (true){ for (int i = 1; i <= 5; i++) { Thread.sleep(1000); System.out.println("记时：" + i); } // 线程中断，捕获到InterruptedException异常 d.interrupt(); } } } class D extends Thread{ @Override public void run() { while (true){ for (int i = 0; i < 10; i++) { System.out.println("吃包子：" + i); } try { System.out.println("休息中"); // 睡眠20秒 sleep(1000 * 20); } catch (InterruptedException e) { System.out.println("休息中断"); } } } } -
yield：线程礼让，让出cpu，让其他进程执行，但礼让的时间不确定，所以不一定礼让成功
-
join：线程插队，插队的线程一旦插队成功，则肯定执行完插入的线程的所有任务
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException {
T2 t2 = new T2();
t2.start();
for (int i = 1; i <= 20; i++) {
System.out.println(Thread.currentThread().getName() + "吃包子" + i);
Thread.sleep(1000);
if (i == 5){
// Thread.yield();
// 主线程停止执行，t2线程执行完毕后，主线程再执行
t2.join();
}
}
}
}
class T2 extends Thread{
@Override
public void run() {
for (int i = 1; i <= 20; i++) {
System.out.println(Thread.currentThread().getName() + "：吃包子" + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
15.5 守护线程
- 用户线程：也叫工作线程，当线程的任务执行完或通知方式结束。
- 守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束。常见的守护线程：垃圾回收机制
设置守护进程的方法：setDaemon(true)
public class ThreadDaemon_ {
public static void main(String[] args) throws InterruptedException {
MyDaemon myDaemon = new MyDaemon();
// 如果我们希望main线程结束后，子进程自动结束
// 只需要将子进程设置为守护进程即可
//注意需要先设置为守护线程，然后再调用start方法，如果先调用start方法，然后设置守护线程，会抛出异常
myDaemon.setDaemon(true);
myDaemon.start();
for (int i = 0; i < 5; i++) {
System.out.println(i);
Thread.sleep(1000);
}
System.out.println("主线程结束");
}
}
class MyDaemon extends Thread{
@Override
public void run() {
while (true){
System.out.println("守护进程在执行~~");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
15.6 线程状态
官方文档显示有6种状态
不过上面的RUNNABLE状态可以细分为Runnable（可执行）和Running（正在执行）两种状态，这样就可以看做共有7中状态
public class ThreadState {
public static void main(String[] args) throws InterruptedException {
T4 t4 = new T4();
System.out.println(t4.getName() + ": " + t4.getState());//输出线程名称和状态
t4.start();
while (true){ // 每500毫秒打印一次t4线程的状态
System.out.println(t4.getName() + ": " + t4.getState());
Thread.sleep(500);
if (t4.getState() == Thread.State.TERMINATED){ // 如果t4线程状态为TERMINATED，则退出打印循环
System.out.println(t4.getName() + ": " + t4.getState());
break;
}
}
}
}
class T4 extends Thread{
@Override
public void run() {
// 子线程每秒打印一个数字，打印10次线程结束，进入TERMINATED状态
for (int i = 1; i <= 10; i++) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
15.7 Synchronized
当多个线程同时运行到被synchronized修饰的代码时，只有一个线程可以同时执行，即线程在这里需要排队执行
使用方式：
- 同步代码块
synchronized (对象) { // 对象是互斥锁
// 需要被同步的代码
}
- 同步方法
public synchronized void m1(){
// 需要被同步的代码
}
15.8 互斥锁
- java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性
- 每个对象都对应于一个可称为"互斥锁"的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能有一个线程访问。
- 同步的局限性：导致程序的执行效率降低
- 同步方法(非静态)的锁可以是this，也可以是其他对象(要求是同一个对象)
- 同步方法(静态)的锁为当前类本身
用synchronized修饰的方法虽然没有写，其实也是有锁的，非静态的方法默认锁对象：this，静态方法默认锁对象：当前类.class
下面代码是非静态的，三个线程同一时刻只有一个线程可以获得锁进入代码块，每个对象都有一个锁，锁是this，也就是当前对象。如果把锁换成lock也能有同样的效果。如果T5继承Thread，创建多个对象start，则无法实现同步，因为每个对象都能得到自己的锁
public class Lock {
public static void main(String[] args) {
T5 t5 = new T5();
new Thread(t5).start();
new Thread(t5).start();
new Thread(t5).start();
// 如果T5继承Thread，创建多个对象start，则无法实现同步
// new T5().start();
// new T5().start();
// new T5().start();
}
}
class T5 implements Runnable{
private int i = 100;
private Object lock = new Object();
@Override
public void run() { // i--，并打印i的值
while (i >= 0){
// synchronized (lock)
synchronized (this){
i--;
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
下面代码是静态的，三个线程同一时刻只有一个线程可以获得锁进入代码块，锁是T6的字节码，也可以用其他类的字节码也可以作为锁
public class LockState {
public static void main(String[] args) {
new T6().start();
new T6().start();
new T6().start();
}
}
class T6 extends Thread{
// i为静态的，多个对象操作同一个i
private static int i = 100;
@Override
public void run() { // i--，并打印i的值
while (i >= 0){
// 锁是T6的字节码，也可以用其他类的字节码也可以作为锁
// synchronized (Object.class)
synchronized (T6.class){
i--;
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
15.9 死锁
不合理的代码逻辑有可能导致死锁，即多个线程彼此等待对方释放锁，导致多个线程都无法继续下一步，一直等待下去
实例：
在下面代码中，Lock1拿到了String锁，等待Object锁，而Lock2拿到了Object锁，等待String锁，两个互相等待对方，就出现死锁
public class Lock01 {
public static void main(String[] args) {
Lock lock1 = new Lock(true);
Lock lock2 = new Lock(false);
lock1.start();
lock2.start();
}
}
class Lock extends Thread{
private boolean fool;
public Lock(boolean fool) {
this.fool = fool;
}
@Override
public void run() {
if(fool){
synchronized (String.class){
System.out.println(Thread.currentThread().getName() + "进入1");
synchronized (Object.class){
System.out.println(Thread.currentThread().getName() + "进入2");
}
}
}else {
synchronized (Object.class){
System.out.println(Thread.currentThread().getName() + "进入3");
synchronized (String.class){
System.out.println(Thread.currentThread().getName() + "进入4");
}
}
}
}
}
15.10 释放锁
释放锁的情况：
- 当前线程的同步方法、同步代码块结束
- 当前线程在同步代码块、同步方法遇到break、return
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
- 当前线程在同步代码块、同步方法中执行了线程对象的 wait() 方法，当前线程暂停，并释放锁。
不释放锁的情况：
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，但不会释放锁
- 线程执行同步代码块时，其他线程调用了改线程的suspend()方法将该线程挂起，该线程不会释放锁（suspend()和resume()方法已经不推荐使用）
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
