Java多线程——线程的创建方式

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());
 }