一、线程的生命周期
线程是一个动态执行的过程，它也有一个从产生到死亡的过程。
下图显示了一个线程完整的生命周期
- 新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序start() 这个线程。
- 就绪状态:
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
- 运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
- 阻塞状态:
如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
-
等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
-
同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
-
其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
-
- 死亡状态:
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态
二、线程的优先级
具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台
三、创建一个线程
Java 提供了三种创建线程的方法：
- 通过实现 Runnable 接口
- 通过继承 Thread 类本身
- 通过 Callable 和 Future 创建线程
1）实现 Runnable 接口来创建线程
创建一个线程，最简单的方法是创建一个实现 Runnable 接口的类，为了实现 Runnable，一个类只需要执行一个方法调用 run()
一、创建一个对象类 package test_synthronized; public class Foo { int x=100; public int getX() { return x; } public int fix(int y) { synchronized(this){ x=x-y; System.out.println("线程"+Thread.currentThread().getName() + "运行结束，减少“" + y + "”，当前值为：" + x);} return x; } } 二、创建一个线程类 package test_synthronized; /** * 线程的同步与锁 */ public class Thread_synchronized_01 implements Runnable{ private Foo foo=new Foo(); public static void main(String[] args) { Thread_synchronized_01 syn=new Thread_synchronized_01(); Thread t1=new Thread(syn,"t1"); Thread t2=new Thread(syn,"t2"); t1.start(); t2.start(); } /* (non-Javadoc) * @see java.lang.Runnable#run() */ public void run() { for (int i = 0; i < 3; i++) { this.fix(30); try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } /* * t1 : 当前foo对象的x值= 40 t2 : 当前foo对象的x值= 40 t1 : 当前foo对象的x值= -20 t2 : 当前foo对象的x值= -50 t1 : 当前foo对象的x值= -80 t2 : 当前foo对象的x值= -80 * 从结果发现，这样的输出值明显是不合理的。原因是两个线程不加控制的访问Foo对象并修改其数据所致。 如果要保持结果的合理性，只需要达到一个目的，就是将对Foo的访问加以限制，每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。 在具体的Java代码中需要完成一下两个操作： 把竞争访问的资源类Foo变量x标识为private； 同步哪些修改变量的代码，使用synchronized关键字同步方法或代码。 */ System.out.println(Thread.currentThread().getName() + " : 当前foo对象的x值= " + foo.getX()); } } public int fix(int y) { return foo.fix(y); } } 三、结果 线程t1运行结束，减少“30”，当前值为：70 t1 : 当前foo对象的x值= 70 线程t1运行结束，减少“30”，当前值为：40 t1 : 当前foo对象的x值= 40 线程t1运行结束，减少“30”，当前值为：10 t1 : 当前foo对象的x值= 10 线程t2运行结束，减少“30”，当前值为：-20 t2 : 当前foo对象的x值= -20 线程t2运行结束，减少“30”，当前值为：-50 t2 : 当前foo对象的x值= -50 线程t2运行结束，减少“30”，当前值为：-80 t2 : 当前foo对象的x值= -80
2) 继承Thread来创建线程
第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。
继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。
该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例
package test_synthronized; public class Thread_synchronized_02 {
class MyThread extends Thread{ private Foo foo; /**当前值*/ private int y = 0; MyThread(String name, Foo foo, int y) { super(name); this.foo = foo; this.y = y; } public void run() { foo.fix(y); } } public static void main(String[] args) { Thread_synchronized_02 run = new Thread_synchronized_02(); Foo foo=new Foo(); MyThread t1 = run.new MyThread("线程A", foo, 10); MyThread t2 = run.new MyThread("线程B", foo, 2); MyThread t3 = run.new MyThread("线程C", foo, 3); MyThread t4 = run.new MyThread("线程D", foo, 5); t1.start(); t2.start(); t3.start(); t4.start(); } } 结果 线程线程A运行结束，减少“10”，当前值为：90 线程线程C运行结束，减少“3”，当前值为：87 线程线程B运行结束，减少“2”，当前值为：85 线程线程D运行结束，减少“5”，当前值为：80
3) 通过 Callable 和 Future 创建线程
-
1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
-
2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
-
3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
-
4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值
package test_synthronized; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class CallableThread implements Callable<Integer> { public Integer call() throws Exception { int i = 0; for(;i<8;i++) { System.out.println(Thread.currentThread().getName()+" "+i); } return i; } public static void main(String[] args) { CallableThread callableThread=new CallableThread(); FutureTask<Integer> ft=new FutureTask<Integer>(callableThread); for(int i = 0;i < 8;i++) { System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i); if(i==2) { new Thread(ft,"有返回值的线程").start(); } } try { System.out.println("子线程的返回值："+ft.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } } 结果 main 的循环变量i的值0 main 的循环变量i的值1 main 的循环变量i的值2 main 的循环变量i的值3 有返回值的线程 0 main 的循环变量i的值4 有返回值的线程 1 main 的循环变量i的值5 有返回值的线程 2 main 的循环变量i的值6 有返回值的线程 3 main 的循环变量i的值7 有返回值的线程 4 有返回值的线程 5 有返回值的线程 6 有返回值的线程 7 子线程的返回值：8
四、线程的三种方式的对比
-
1. 采用实现 Runnable、Callable 接口的方式创见多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
-
2. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。
原创文章，作者：Maggie-Hunter，如若转载，请注明出处：https://blog.ytso.com/tech/pnotes/17738.html