目录
一、创建线程的方式
1、继承Thread类
创建一个自定义的线程类并继承标准库中的Thread类：
class MyThread extends Thread{
@Override
//重写父类的run方法
public void run() {
System.out.println("这是继承Thread类创建的线程");
}
}
public class Thread1 {
public static void main(String[] args) {
//创建实例
MyThread thread = new MyThread();
//调用start方法后才会在系统上创建一个线程
thread.start();
}
}其中，重写父类的run()方法是给MyThread类创建的线程安排任务，main()方法中创建一个MyThread实例后，调用父类的start()方法，新创建的线程就会执行子类的run()方法中的逻辑(此处发生了动态绑定)。
代码运行结果：
2、实现Runnable接口
class MyThread2 implements Runnable{
@Override
public void run() {
System.out.println("这是实现Runnable接口创建的线程");
}
}
public class Thread2 {
public static void main(String[] args) {
Runnable runnable = new MyThread2();
//需要将Runnable实例作为Thread构造方法的参数
Thread thread = new Thread(runnable);
thread.start();
}
}代码运行结果：
3、匿名内部类中创建Thread子类对象
public class Thread3 {
public static void main(String[] args) {
Thread thread = new Thread(){
@Override
public void run() {
System.out.println("匿名内部类创建Thread子类对象");;
}
};
thread.start();
}
}代码运行结果：
4、匿名内部类中创建Runnable子类对象
public class Thread4 {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类创建Runnable子类对象");
}
});
thread.start();
}
}代码运行结果：
注意和匿名内部类创建Thread子类对象作区分~
5、lambda表达式创建Runnabl子类对象
public class Thread5 {
public static void main(String[] args) {
Thread thread = new Thread(()->{
System.out.println("lambda表达式创建Runnable子类对象");
});
thread.start();
}
}代码运行结果：
lambda表达式的写法比较简洁明了，推荐使用这种写法~
二、Thread的常见构造方法
| 方法 | 说明 |
| Thread() | 创建线程对象 |
| Thread(Runnable target) | 使用Runnable对象创建线程对象(上述第二种创建线程的方式) |
| Thread(String name) | 创建线程对象，并命名 |
| Thread(Runnable target,String name) | 使用Runnable对象创建线程对象并命名 |
上表中第三个和第四个Thread的构造方法，可以给线程命名。我们先创建两个线程，一个是默认名，一个是自定义名：
public static void main(String[] args) {
Thread thread1 = new Thread(()->{
while (true){
System.out.println("hello thread");
try {
Thread.sleep(1100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"这是一个自定义的线程");
Thread thread2 = new Thread(()->{
while (true){
System.out.println("hello world");
try {
Thread.sleep(1100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread1.start();
thread2.start();
}线程的名字等信息可以在jconsole中看到：
打开jconsole之前，需要确保线程在运行状态(所以上面两个线程都会死循环的打印内容)，打开jconsole后，选择本地进程，找到正在运行的线程所在的类，点击连接：
有了自定义线程名后，如果同时有多个线程在执行，我们在观察时就会方便很多。
三、启动一个线程
在创建一个线程实例后，并不会在操作系统上创建一个线程，只有当这个实例调用strat方法后，才会真正在操作系统上创建一个线程，然后该线程会去执行run方法中的代码，执行完run方法后，该线程就会被销毁。
四、获取当前线程
通过类名调用currentThread()方法即可获取当前正在运行的线程的引用：
public static void main(String[] args) {
Thread thread = Thread.currentThread();
System.out.println(thread.getName());//获取当前线程名字
}
代码运行结果：
五、等待一个线程
| 方法 | 说明 |
| join() | 无时间限制地等待，直到线程结束 |
| join(long millis) | 最多等待millis毫秒 |
| join(long millis, int nanos) | 最多等待millis毫秒，nanos纳秒(更精确) |
示例：计算一个全局变量在一个线程中自增一千万次所需要的时间。
static int count;
public static void main(String[] args) {
Thread thread = new Thread(()->{
for (int i = 0; i < 1000_0000; i++) {
count++;
}
},"T");
long beg = System.currentTimeMillis();//获取线程开始执行的时间
thread.start();
long end = System.currentTimeMillis();//获取线程结束执行的时间
System.out.println("总共用时:"+(end - beg) + "ms");
}如果直接这样写代码，就会发现运行结果为：
原因：当前进程中有main线程和thread对象创建的T线程，两个线程在进程中是“并发”执行的，main线程并不会等到T线程执行完run方法中count的一千万次自增后再获取end的值，而是会不停地往下执行，即获取到beg的值后，会立刻获取end的值，因此end和beg的差值不足1ms。
所以，我们需要使用join方法让main线程等到T线程执行完run方法之后再继续往后执行：
static int count;
public static void main(String[] args) {
Thread thread = new Thread(()->{
for (int i = 0; i < 1000_0000; i++) {
count++;
}
},"T");
long beg = System.currentTimeMillis();//获取线程开始执行的时间
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();//获取线程结束执行的时间
System.out.println("总共用时:"+(end - beg) + "ms");
}调用join方法可能会抛出异常，使用 try-catch 或 throws 处理一下即可。
再次运行代码的结果：
六、休眠当前线程
| 方法 | 说明 |
| sleep(long millis) | 休眠当前线程millis毫秒 |
| sleep(long millis,int nanos) | 休眠当前线程misslis毫秒，nanos纳秒 |
sleep方法也是一个静态方法，需要通过类名进行调用。作用是让当前线程休眠一段时间后再继续往后执行，调用sleep方法也需要处理InterruptedException这个异常。
示例： 让main线程休眠5秒再往后执行。
public static void main(String[] args) throws InterruptedException {
long beg = System.currentTimeMillis();
Thread.sleep(5000);
long end = System.currentTimeMillis();
System.out.println("main线程休眠时间:"+(end-beg)+"ms");
}你以为会打印5000ms？实际上打印的是：
调用sleep方法后线程会进入阻塞状态，休眠完5000ms后线程才会恢复到就绪状态，状态之间的切换也会消耗时间，因此线程的实际休眠时间会大于参数设置的时间。
七、中断当前线程
根据上文可以知道，线程在执行完run()方法后才会结束，那么可不可以让线程提前结束呢？
线程中断就是让线程提前结束的方式(本质上是让run方法提前结束，并非是在run方法执行过程中强制结束进程)，但是能否提前结束也取决于run方法是如何实现的。
线程中断的方法：
(1) 自定义一个标志位，作为线程是否结束的标记
public class Test {
static boolean isQuit;//自定义的标志位
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
while (!isQuit){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("T线程结束");
},"T");
thread.start();
Thread.sleep(3000);//main线程休眠3秒
isQuit = true;//标志位设置为true
System.out.println("设置让T线程提前结束");
}
}代码运行结果：
本来T线程会在run方法中死循环的打印"hello thread"，但是我们通过设置标志位，让T线程提前结束。
(2)使用标准库中的标志位
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
while (!Thread.currentThread().isInterrupted()){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("T线程结束");
},"T");
thread.start();
Thread.sleep(3000);
thread.interrupt();//设置标志位为true
System.out.println("设置标志位让T线程提前结束");
}上述代码中的isInterrupted()方法是判断当前线程是否被中断，线程在正常运行时，该方法的返回值是false，即未被中断。而interrupt()方法则是将当前线程设置为中断状态，即将isInterrupted()方法的返回值设置为true。
代码执行结果：
从上图中可以发现，将标志位设置为True后，T线程在抛出一个异常信息后继续循环打印“hello thread”，线程并没有结束。
因为thread在调用interrupt()方法时，T线程存在两种状态：
(1)运行状态
此时调用interrupt()方法，可以顺利地中断进程。
(2)阻塞状态
T线程在调用sleep()方法后就会进入阻塞状态，此时调用interrupt()方法，不会设置标志位为True，而是会把T线程从阻塞状态提前唤醒，抛出InterruptedException异常。
所以我们要想中断进程，只需要在抛出异常时加一个break即可：
在Java中，中断线程并不一定是强制执行的，而是由线程自身进行判定处理(取决于代码是如何实现的)，一般有三种处理方式：
(1)立即结束：直接break
(2)不予理会：不作处理，继续执行run方法的代码
(3)稍后结束：休眠一段时间再break
330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
