Thread类的基本用法
1.线程创建
1.继承Thread类，重写run()方法
class MyThread extends Thread{
@Override
public void run() {
System.out.println("hello thread");
}
}
public class Demo1 {
public static void main(String[] args) {
MyThread t=new MyThread();//把线程和线程要完成的任务耦合在一起
t.start();//另外启动新线程，执行run中的逻辑，是一个单独执行流，和现有执行流不相关。并发执行
System.out.println("hello main");
}
}
2.实现Runnable接口，重写run()方法
class MyRunnable implements Runnable{
@Override
public void run() {
while (true) {
System.out.println("hello MyRunnable");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Demo2 {
public static void main(String[] args) {
MyRunnable myRunnable=new MyRunnable();
Thread t=new Thread(myRunnable);//把线程要干的事和线程分开，使用Runnable专门表示线程要完成的工作
t.start();
while (true){
System.out.println("hello main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}3.继承Thread类，使用匿名内部类
public class Demo3 {
/**
*使用匿名内部类，创建thread子类同时实例化出一个thread对象
* @param args
*/
public static void main(String[] args) {
Thread t=new Thread(){
@Override
public void run() {
while(true){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
};
t.start();
while(true){
System.out.println("hello main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
4.实现Runnable接口，使用匿名内部类
public class Demo4 {
/**
* 使用匿名内部类 实现Runnable接口
* @param args
*/
public static void main(String[] args) {
Thread t=new Thread(new Runnable() {
@Override
public void run() {
while(true){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
});
t.start();
while(true){
System.out.println("hello main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
5.使用lambda表达式（推荐）
public class Demo5 {
/**
* lambda表达式，推荐写法
* @param args
*/
public static void main(String[] args) {
Thread t=new Thread(()->{
while (true){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
while(true){
System.out.println("hello main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
2.启动线程（start和run的区别）
class MyThread extends Thread{
@Override
public void run() {
while(true) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Demo1 {
public static void main(String[] args) {
MyThread t=new MyThread();
//t.run();直接调用run
t.start();
while (true){
System.out.println("hello main");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
第一个截图是调用start，是创建线程，在新线程里面执行代码，和main线程并发执行。
第二个截图是调用run，没有创建线程，而是在原来的main线程执行代码
线程中断
本质是让run方法快点结束，而不是让run执行一般中止。
方法1：自己定义一个标志位，作为线程是否结束的标志
public class Demo9 {
public static boolean isQuit=false;//自定义一个标志
public static void main(String[] args) {
Thread t=new Thread(()->{
while (!isQuit) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
isQuit=true;//3秒后线程结束
}
}
方法2：使用标准库自带的标记
public class Demo10 {
public static void main(String[] args) {
Thread t = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
//currentThread()是一个静态方法，通过它可以获得当前线程对应的Thread对象
//isInterrupted()用于判定标志位
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//throw new RuntimeException(e);
//1.立即结束线程
//break;
//2.不做处理
//3.稍后处理
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
throw new RuntimeException(ex);
}
break;
}
}
});
t.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
t.interrupt();//通过他中断线程，设置标志位为true
/*
interrupt方法有两种情况
1.t线程在运行时，会设置标志位为true
2.t线程在阻塞状态（sleep)，不会设置标志位，而是触发InterruptedException，这个异常会把sleep提前唤醒.
所以处理异常时直接break;
*/
}
}
线程等待
线程之间的调度是不确定的，可以通过join()方法控制线程的结束顺序
public class Demo11 {
public static void main(String[] args) {
Thread t=new Thread(()->{
for (int i = 0; i < 5; i++) {
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
try {
t.join();//main线程进入阻塞，t线程继续参与调度
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("hello main");
}
}
如果调用join方法之前，t线程已经结束，此时join不需要阻塞等待。
线程休眠sleep()
操作系统管理线程PCB的时候，是有多了链表的。其中有阻塞队列，就绪队列，调用sleep()时PCB会从 就绪队列移动 到 阻塞队列。只有就绪队列才会参与cpu调度，当sleep时间到了就会从新回到就绪队列（不代表立即在cpu上执行）