Java多线程——线程的创建方式
摘要：本文主要学习了线程的创建方式，线程的常用属性和方法，以及线程的几个基本状态。
部分内容来自以下博客：
https://www.cnblogs.com/dolphin0520/p/3913517.html
https://www.cnblogs.com/trust-freedom/p/6606594.html
线程的创建
Thread类和Runnable接口
Thread类实现了Runnable接口，实现了Runnable接口里的run()方法。
事实上，查看Thread类的实现源代码会发现Thread类是实现了Runnable接口的。
在Java中，这2种方式都可以用来创建线程去执行子任务，具体选择哪一种方式要看自己的需求。直接继承Thread类的话，可能比实现Runnable接口看起来更加简洁，但是由于Java只允许单继承，所以如果自定义类需要继承其他类，则只能选择实现Runnable接口。
不论哪种方式创建线程，都必须重写run()方法，在run()方法中定义需要执行的任务。
创建好了自己的线程类之后，就可以创建线程对象了，然后通过start()方法去启动线程。注意，不是调用run()方法启动线程，run()方法中只是定义需要执行的任务，如果调用run()方法，即相当于在主线程中执行run()方法，跟普通的方法调用没有任何区别，此时并不会创建一个新的线程来执行定义的任务。
创建线程
在Java中创建线程有两种方法：
◆ 创建继承了Thread类的对象。
public class Demo {
public static void main(String[] args) {
Thread t1 = new DemoThread("线程一");
Thread t2 = new DemoThread("线程二");
t1.start();
t2.start();
}
}
class DemoThread extends Thread {
public DemoThread(String name) {
this.setName(name);
}
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
System.out.println(Thread.currentThread().getName() + " >>> " + i);
}
}
}
◆ 创建传入一个实现了Runnable接口的类的Thread对象。
public class Demo {
public static void main(String[] args) {
DemoThread dt = new DemoThread();
Thread t1 = new Thread(dt, "线程一");
Thread t2 = new Thread(dt, "线程二");
t1.start();
t2.start();
}
}
class DemoThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
System.out.println(Thread.currentThread().getName() + " >>> " + i);
}
}
}
线程的常用属性和方法
属性
priority：线程的优先级。最低为1，最高为10，默认为5。优先级高的线程获取CPU时间片的概率高。
threadStatus：线程的状态。常见的状态有NEW、RUNNABLE、BLOCKED、WAITING。
构造方法
Thread()：使用这种方式创建的线程，需要重写Thread类里的run()方法。
Thread(Runnable target)：使用这种方式创建的线程，需要实现Runnable接口里的run()方法。
静态方法
Thread.currentThread()：获取当前运行的线程。
常用方法
void run()：线程执行任务的主要代码。如果没有实现Runnable接口里的run()方法，则需要重写Thread类里的run()方法。
void start()：启动线程的方法，虚拟机会调用线程的run()方法。只用调用了start()方法，才会启动一个新的线程执行定义的任务。
void sleep(long millis)：本地方法，让当前线程休眠指定时间。sleep()方法不会释放占用的锁。
void join()：相当于void join(0)，传入0代表一直等待到结束。
void join(long millis)：执行指定的线程一段时间，直到执行时间达到传入的时间长度或者线程执行完毕。
线程的状态
NEW：线程刚创建时具有的状态。
public static void main(String[] args) {
Thread thread = new Thread();
System.out.println(thread.getState());
}
RUNNABLE：线程正在运行，线程获取CPU的时间片。
public static void main(String[] args) {
Thread thread = new Thread();
thread.start();
System.out.println(thread.getState());
}
BLOCKED：线程进入阻塞状态。假如有两个都是同步安全的线程，当一个线程处于RUNNABLE状态时，则另一个线程处于BLOCKED状态。
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
synchronized (Object.class) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
Thread t2 = new Thread() {
public void run() {
synchronized (Object.class) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
t1.start();
t2.start();
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(t2.getState());
}
WAITTING：程序处于等待状态，调用wait()、join()、await()、lock()等方法，都会使线程处于WAITTING状态，需要注意的是这些方法必须是无参数的。
public static void main(String[] args) {
Thread t = new Thread() {
public void run() {
synchronized (Object.class) {
try {
join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
t.start();
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(t.getState());
}
TIMED_WAITING：程序处于限时等待状态，调用wait()、join()、await()、lock()、sleep()等方法，都会使线程处于TIMED_WAITING状态，需要注意的是这些方法必须加入参数。
public static void main(String[] args) {
Thread t = new Thread() {
public void run() {
synchronized (Object.class) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
t.start();
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(t.getState());
}