Java中线程的实现

在Java中实现多线程有两种手段，一种是继承Thread类，另一种就是实现Runnable接口。下面我们就分别来介绍这两种方式的使用。

（1）JAVA中创建线程有两种方式：

1）通过继承Thread类，通常应该重写其run方法，将线程运行的逻辑放在其中。因为Thread中的run方法是一个空实现。
2）通过实现Runnable接口，然后通过实例化一个Thread实例并将自身作为运行目标。

那么在使用中，应该使用那种方式呢？当然使用哪种方式都行，然而在Runnable接口API文档中已经详细地说明该如何选择这两种方式：大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类（Thread）创建子类。

在第二种方式中，经常会使用内部类的方式来使用。

实现Runnable接口

  2. /*
  3. 实现Runnable接口，作为线程的实现类
  4.  */
  5. class MyThread implements Runnable{
  7.     //表示线程的名称
  8.     private String name;
  10.     //通过构造方法配置name属性
  11.     public MyThread(String name){
  12.         this.name = name;
  13.     }
  15.     //覆写run()方法，作为线程的操作主体
  16.     @Override
  17.     public void run() {
  18.         for (int i=0;i<10;i++){
  19.             System.out.println(name+"运行，i="+i);
  20.         }
  21.     }
  22. }
  24. public class RunnableDemo01 {
  25.     public static void main(String args[]){
  26.         //实例化对象
  27.         MyThread mt1 = new MyThread("线程A");
  28.         //实例化对象
  29.         MyThread mt2 = new MyThread("线程B");
  30.         //实例化Tread类对象
  31.         Thread t1 = new Thread(mt1);
  32.         //实例化Tread类对象
  33.         Thread t2 = new Thread(mt2);
  34.         //启动多线程
  35.         t1.start();
  36.         t2.start();
  37.     }
  38. }

程序运行结果：
image.png

继承Thread类

  2. /*
  3. 继承Thread类，作为线程的实现类
  4.  */
  5. class MyThread2 extends Thread{
  7.     //表示线程的名称
  8.     private String name;
  10.     //通过构造方法配置name属性
  11.     public MyThread2(String name){
  12.         this.name = name;
  13.     }
  15.     //覆写run()方法，作为线程的操作主体
  16.     public void run() {
  17.         for (int i=0;i<10;i++){
  18.             System.out.println(name+"运行，i="+i);
  19.         }
  20.     }
  21. }
  23. public class ThreadDemo02 {
  25.     public static void main(String args[]){
  26.         // 实例化对象
  27.         MyThread2 mt1 = new MyThread2("线程A");
  28.         // 实例化对象
  29.         MyThread2 mt2 = new MyThread2("线程B");
  30.         // 调用线程主体
  31.         mt1.start();
  32.         // 调用线程主体
  33.         mt2.start();
  35.     }
  36. }

程序运行结果：
image.png
从程序可以看出，现在的两个线程对象是交错运行的，哪个线程对象抢到了CPU资源，哪个线程就可以运行，所以程序每次的运行结果肯定是不一样的，在线程启动虽然调用的是start()方法，但实际上调用的却是run()方法定义的主体。

Thread类与Runnable接口的区别与联系

Thread类的定义：

  1. public class Thread implements Runnable

从Thread类的定义可以清楚的发现，Thread类也是Runnable接口的子类，但在Thread类中并没有完全实现Runnable接口中的run()方法，下面是Thread类的部分定义。

  1. Private Runnable target；
  2. public Thread(Runnable target,String name){
  3.     init(null,target,name,0);
  4. }    
  5. private void init(ThreadGroup g,Runnable target,String name,long stackSize){
  6.     ...
  7.     this.target=target;
  8. }
  9. public void run(){
  10.     if(target!=null){
  11.     target.run();
  12.   }
  13. }

从定义中可以发现，在Thread类中的run（）方法调用的是Runnable接口中的run()方法，也就是说此方法是由Runnable子类完成的，所以**如果要通过继承Thread类实现多线程，则必须覆写run()。创建线程时，必须使用该类。该类封装了线程的行为。（使用Runnable接口也要使用Thread类）
实际上Thread类和Runnable接口之间在使用上也是有区别的，如果一个类继承Thread类，则不适合于多个线程共享资源，而实现了Runnable接口，就可以方便的实现资源的共享。
Runnable 为非 Thread 子类的类提供了一种激活方式。通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread 的子类。大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口**。

（2）启动线程

因为run方法是不能显示调用的，启动一个线程不是调用run方法，而是调用Thread类的start方法。
如果是 run（）方法的话，那就是调用普通的方法run(), 会依次执行，并不会并发执行。
另外，也要注意， 同一个线程，只能启动一次， 不能重复两次。


（3）线程的状态

要想实现多线程，必须在主线程中创建新的线程对象。任何线程一般具有5种状态，即创建，就绪，运行，阻塞，终止。

  • 创建

用构造方法创建一个线程对象，该新的线程对象处于新建状态，此时，它已经有了相应的内存空间和其他资源，但仍处于不可运行的状态。新建一个线程对象可采用Thread 类的构造方法来实现，例如 Thread thread=new Thread()。

  • 就绪

新建线程对象后，调用该线程的 start() 方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待 CPU 服务，这表明它已经具备了运行条件。

  • 运行

当就绪状态被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的 run() 方法。run() 方法定义该线程的操作和功能。

  • 阻塞

一个正在执行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入/输出操作，会让 CPU 暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(),suspend(),wait() 等方法，线程都将进入阻塞状态，发生阻塞时线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入**就绪状态**。

  • 终止

线程调用 stop() 方法时或 run() 方法执行结束后，即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。

在此提出一个问题，Java 程序每次运行至少启动几个线程？

回答：至少启动两个线程，每当使用 Java 命令执行一个类时，实际上都会启动一个 JVM，每一个JVM实际上就是在操作系统中启动一个线程，Java 本身具备了垃圾的收集机制。所以在 Java 运行时至少会启动两个线程，一个是 main 线程，另外一个是垃圾收集线程。

取得和设置线程的名称

  1. class MyThread3 implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         for(int i = 0;i < 3;i++){
  5.             System.out.println(Thread.currentThread().getName() + "运行：i="+i);
  6.         }
  7.     }
  8. }
  10. public class RunnableDemo03 {
  11.     public static void main(String args[]){
  12.         //实例化对象
  13.         MyThread3 mt1 = new MyThread3();
  14.         //实例化Tread类对象
  15.         Thread t1 = new Thread(mt1,"线程A");
  16.         //实例化Tread类对象
  17.         Thread t2 = new Thread(mt1,"线程B");
  18.         //启动多线程
  19.         t1.start();
  20.         t2.start();
  21.     }
  22. }

程序运行结果：
image.png

（4）线程的操作方法**

  • 线程的强制运行

在线程操作中，可以使用 join() 方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续执行。

  1. class MyThread4 implements Runnable{
  2.     public void run(){
  3.         for(int i = 0;i < 3;i++){
  4.             System.out.println(Thread.currentThread().getName() + "运行：i="+i);
  5.         }
  6.     }
  7. }
  9. public class ThreadJoinDemo {
  10.     public static void main(String args[]){
  11.         MyThread4 mt = new MyThread4();
  12.         Thread t = new Thread(mt,"线程");
  13.         t.start();
  14.         for(int i = 0;i < 4;i++){
  15.             if(i > 1){
  16.                 try {
  17.                     t.join();
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.             }
  22.             System.out.println("Main线程："+i);
  23.         }
  24.     }
  25. }

程序运行结果：
image.png

  • 线程的休眠

在程序中允许一个线程进行暂时的休眠，直接使用 Thread.sleep() 即可实现休眠。

  1. class MyThread5 implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         for (int i = 0;i <3;i++){
  5.             try {
  6.                 if (i == 2){
  7.                     Thread.sleep(1500);
  8.                 }
  9.             } catch (InterruptedException e) {
  10.                 e.printStackTrace();
  11.             }
  12.             System.out.println(Thread.currentThread().getName() + "运行：i="+i);
  13.         }
  14.     }
  15. }
  16. public class ThreadSleepDemo {
  17.     public static void main(String argu[]){
  18.         MyThread5 mt = new MyThread5();
  19.         Thread t = new Thread(mt);
  20.         t.start();
  21.     }
  22. }

程序运行结果：
image.png

  • 中断线程

当一个线程运行时，另外一个线程可以直接通过interrupt()方法中断其运行状态。

  1. class MyThread6 implements Runnable{
  2.     @Override
  3.     public void run() { // 覆写run()方法
  4.         System.out.println("1、进入run()方法");
  5.         try {
  6.             Thread.sleep(10000); // 线程休眠10秒
  7.             System.out.println("2、已经完成了休眠") ;
  8.         } catch (InterruptedException e) {
  9.             System.out.println("3、休眠被终止") ;
  10.             return ; // 返回调用处
  11.         }
  12.         System.out.println("4、run()方法正常结束") ;
  13.     }
  14. }
  15. public class ThreadInterruptDemo {
  16.     public static void main(String argu[]) {
  17.         MyThread6 mt = new MyThread6();
  18.         Thread t = new Thread(mt, "线程");
  19.         t.start();
  20.         try {
  21.             Thread.sleep(2000);
  22.         } catch (InterruptedException e) {
  23.             System.out.println("5、休眠被终止");
  24.         }
  25.         t.interrupt(); // 中断线程执行
  26.     }
  27. }

程序运行结果：
image.png

  • 后台线程

在 Java 程序中，只要前台有一个线程在运行，则整个 Java 进程都不会消失，所以此时可以设置一个后台线程，这样即使 Java 线程结束了，此后台线程依然会继续执行，要想实现这样的操作，直接使用 setDaemon() 方法即可。

  1. class MyThread7 implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         while (true){
  5.             System.out.println(Thread.currentThread().getName() + "运行。");
  6.         }
  7.     }
  8. }
  9. public class ThreadDaemonDemo {
  10.     public static void main(String argu[]){
  11.         MyThread7 mt = new MyThread7();
  12.         Thread t = new Thread(mt,"线程");
  13.         t.setDaemon(true);
  14.         t.start();
  15.     }
  16. }

在线程类 MyThread7 中，尽管 run() 方法中是死循环的方式，但是程序依然可以执行完，因为方法中死循环的线程操作已经设置成后台运行。

  • 线程的优先级

在 Java 的线程操作中，所有的线程在运行前都会保持在就绪状态，那么此时，哪个线程的优先级高，哪个线程就有可能会先被执行。

  1. class MyThread8 implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         for (int i = 0;i<3;i++){
  5.             try {
  6.                 Thread.sleep(500);// 线程休眠
  7.             } catch (InterruptedException e) {
  8.                 e.printStackTrace();
  9.             }
  10.             System.out.println(Thread.currentThread().getName() + "运行：i="+i);
  11.         }
  12.     }
  13. }
  14. public class ThreadPriorityDemo {
  15.     public static void main(String argu[]){
  16.         MyThread8 mt = new MyThread8();
  17.         Thread t1 = new Thread(mt,"线程A");
  18.         Thread t2 = new Thread(mt,"线程B");
  19.         Thread t3 = new Thread(mt,"线程C");
  20.         t1.setPriority(Thread.MIN_PRIORITY); // 优先级最低
  21.         t2.setPriority(Thread.MAX_PRIORITY); // 优先级最高
  22.         t3.setPriority(Thread.NORM_PRIORITY);// 优先级最中等
  23.         t1.start();
  24.         t2.start();
  25.         t3.start();
  26.     }
  27. }

程序运行结果：
image.png
从程序的运行结果中可以观察到，线程将根据其优先级的大小来决定哪个线程会先运行，但是需要注意并非优先级越高就一定会先执行，哪个线程先执行将由 CPU 的调度决定。

  • 线程的礼让

在线程操作中，也可以使用 yield() 方法将一个线程的操作暂时让给其他线程执行。

  1. class MyThread9 implements Runnable{
  2.     @Override
  3.     public void run() {
  4.         for (int i = 0;i<3;i++){
  5.             try {
  6.                 Thread.sleep(500);// 线程休眠
  7.             } catch (InterruptedException e) {
  8.                 e.printStackTrace();
  9.             }
  10.             System.out.println(Thread.currentThread().getName() + "运行：i="+i);
  11.             if (i == 1){
  12.                 System.out.println("线程礼让：");
  13.                 Thread.currentThread().yield();
  14.             }
  15.         }
  16.     }
  17. }
  18. public class ThreadYieldDemo {
  19.     public static void main(String argu[]){
  20.         MyThread9 mt = new MyThread9();
  21.         Thread t1 = new Thread(mt,"线程A");
  22.         Thread t2 = new Thread(mt,"线程B");
  23.         t1.start();
  24.         t2.start();
  25.     }
  26. }

程序运行结果：
image.png

（5）同步以及死锁

一个多线程的程序如果是通过 Runnable 接口实现的，则意味着类中的属性被多个线程共享，那么这样就会造成一种问题，如果这多个线程要操作同一个资源时就有可能出现资源同步问题（多线程访问相同一个共享数据时出现的安全隐患的问题）。
以两个线程共同卖票为例：

  1. class MyThread10 implements Runnable{
  2.     private int ticket = 1;   // 假设一共有5张票
  3.     @Override
  4.     public void run() {
  5.         while (true){
  6.             if (ticket <= 0){
  7.                 break;
  8.             }else {
  9.                 try {
  10.                     Thread.sleep(200);
  11.                     System.out.println(Thread.currentThread().getName()+"正在卖出第" +(5-ticket+1) + "张票，剩余"+(--ticket)+"张票");
  12.                 } catch (InterruptedException e) {
  13.                     e.printStackTrace();
  14.                 }
  15.             }
  16.         }
  17.     }
  18. }
  19. public class SyncDemo02 {
  20.     public static void main(String argu[]){
  21.         MyThread10 mt = new MyThread10();
  22.         Thread t1 = new Thread(mt,"线程A");
  23.         Thread t2 = new Thread(mt,"线程B");
  24.         t1.start();
  25.         t2.start();
  26.     }
  27. }

程序运行结果：
image.png
假设，我们还剩最后一张票了，ticket=1，进程A进入run方法，因为ticket>0，所以进程A睡眠200毫秒，在进程A睡眠的过程中，进程B启动了，进入run方法，因为ticket=1>0，所以进程B也睡眠200毫秒，然后，进程A睡眠时间结束，输出：“进程A正在卖出第5张票，剩余0张票”。ticket=0，然后，进程B睡眠时间结束，继续往下运行，输出：“进程A正在卖出第6张票，剩余-1张票”。

解决方法：

同步代码块方式

  1. synchronized(同步对象)｛ 
  2.  需要同步的代码 
  3. ｝
  1. class MyThread10 implements Runnable{
  2.     private int ticket = 5;   // 假设一共有5张票
  3.     @Override
  4.     public void run() {
  5.         while (true){
  6.             try {
  7.                 Thread.sleep(500);
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.             synchronized(this){
  12.                 if (ticket <= 0){
  13.                     break;
  14.                 }else {
  15.                     System.out.println(Thread.currentThread().getName()+"正在卖出第" +(5-ticket+1) + "张票，剩余"+(--ticket)+"张票");
  16.                 }
  17.             }
  18.         }
  19.     }
  20. }
  21. public class SyncDemo02 {
  22.     public static void main(String argu[]){
  23.         MyThread10 mt = new MyThread10();
  24.         Thread t1 = new Thread(mt,"线程A");
  25.         Thread t2 = new Thread(mt,"线程B");
  26.         t1.start();
  27.         t2.start();
  28.     }
  29. }

程序运行结果：
image.png
ticket=5，进程A进入run方法，先睡眠了500毫秒，这时候进程B可能抢到了run方法，也有可能没有抢到，然后，线程A睡眠时间结束后，进入到同步代码块当中（相当于线程A给了同步代码块加了一把锁），执行同步代码块中的代码，当线程A同步代码块，线程B抢到了执行权力，但是它进不去同步代码块（它已经被线程A锁住了），直到线程A执行同步代码块执行完，它会将锁释放掉，然后，进程A和进程B抢夺执行权力，谁抢到了，进入到同步代码块当中，它就会对应的上一把锁，执行完毕后，才会把锁释放掉。**


同步方法方式

除了可以将需要的代码设置成同步代码块外，也可以使用 synchronized 关键字将一个方法声明为同步方法。

  1. synchronized 方法返回值 方法名称（参数列表）｛ 
  3. ｝
  1. class MyThread10 implements Runnable{
  2.     private static int ticket = 5;   // 假设一共有5张票
  3.     @Override
  4.     public void run() {
  5.         sale();
  6.     }
  8.     public static synchronized void sale(){//静态方法和普通方法都可同步方法，不会出现进程安全问题
  9.         //静态方法和普通方法的区别：有无关键字static；对于普通方法，它的锁默认对象是当前本类对象，即this，而静态方法，属于类的，比对象优先存在，所以它使用不了this，它的锁默认对象是当前本类的字节码对象，就是MyThread10.class属性获取的class对象
  10.         while (true){
  11.             if (ticket <= 0){
  12.                 break;
  13.             }else {
  14.                 try {
  15.                     Thread.sleep(200);
  16.                     System.out.println(Thread.currentThread().getName()+"正在卖出第" +(5-ticket+1) + "张票，剩余"+(--ticket)+"张票");
  17.                 } catch (InterruptedException e) {
  18.                     e.printStackTrace();
  19.                 }
  20.             }
  21.         }
  22.     }
  23. }
  25. public class SyncDemo02 {
  26.     public static void main(String argu[]){
  27.         MyThread10 mt = new MyThread10();
  28.         Thread t1 = new Thread(mt,"线程A");
  29.         Thread t2 = new Thread(mt,"线程B");
  30.         t1.start();
  31.         t2.start();
  32.     }
  33. }

程序运行结果：
image.png
所谓的同步方法，指在最初的方法声明上，再加上synchronized关键字，里面的执行代码不发生改变，它是将整个方法锁了起来。只有当最先抢到执行权力的线程A执行完方法后，释放掉锁，线程B再与线程A抢夺执行权利。

Lock锁方式

  1. import java.util.concurrent.locks.Lock;
  2. import java.util.concurrent.locks.ReentrantLock;
  4. class MyThread10 implements Runnable{
  5.     private int ticket = 5;   // 假设一共有5张票
  6.     Lock l = new ReentrantLock();
  7.     @Override
  8.     public void run() {
  9.         while (true){
  10.             try {
  11.                 Thread.sleep(500);
  12.             } catch (InterruptedException e) {
  13.                 e.printStackTrace();
  14.             }
  15.             l.lock();//上锁
  16.             if (ticket <= 0){
  17.                 l.unlock();//解锁
  18.                 break;
  19.             }else {
  20.                 System.out.println(Thread.currentThread().getName()+"正在卖出第" +(5-ticket+1) + "张票，剩余"+(--ticket)+"张票");
  21.                 l.unlock();//解锁
  22.             }
  24.         }
  25.     }
  26. }
  27. public class SyncDemo02 {
  28.     public static void main(String argu[]){
  29.         MyThread10 mt = new MyThread10();
  30.         Thread t1 = new Thread(mt,"线程A");
  31.         Thread t2 = new Thread(mt,"线程B");
  32.         t1.start();
  33.         t2.start();
  34.     }
  35. }

程序运行结果：
image.png

死锁

同步可以保证资源共享操作的正确性，但是过多同步也会产生问题。例如，现在张三想要李四的画，李四想要张三的书，张三对李四说“把你的画给我，我就给你书”，李四也对张三说“把你的书给我，我就给你画”两个人互相等对方先行动，就这么干等没有结果，这实际上就是死锁的概念。
所谓死锁，就是两个线程都在等待对方先完成，造成程序的停滞，一般程序的死锁都是在程序运行时出现的。
下面以一个简单范例说明这个概念：

  1. class Zhangsan{ // 定义张三类
  2.     public void say(){
  3.         System.out.println("张三对李四说：“你给我画，我就把书给你。”") ;
  4.     }
  5.     public void get(){
  6.         System.out.println("张三得到画了。") ;
  7.     }
  8. }
  9. class Lisi{ // 定义李四类
  10.     public void say(){
  11.         System.out.println("李四对张三说：“你给我书，我就把画给你”") ;
  12.     }
  13.     public void get(){
  14.         System.out.println("李四得到书了。") ;
  15.     }
  16. }
  17. public class ThreadDeadLock implements Runnable{
  18.     private static Zhangsan zs = new Zhangsan();
  19.     private static Lisi ls = new Lisi();
  20.     private boolean flag = false ;  // 声明标志位，判断那个先说话
  21.     public void run() {  // 覆写run()方法
  22.         if (flag){
  23.             synchronized (zs){ // 同步张三
  24.                 zs.say();
  25.                 try {
  26.                     Thread.sleep(500);
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.                 synchronized (ls){
  31.                     zs.get();
  32.                 }
  33.             }
  34.         }else {
  35.             synchronized (ls){ // 同步李四
  36.                 ls.say();
  37.                 try {
  38.                     Thread.sleep(500);
  39.                 } catch (InterruptedException e) {
  40.                     e.printStackTrace();
  41.                 }
  42.                 synchronized (zs){
  43.                     ls.get();
  44.                 }
  45.             }
  46.         }
  47.     }
  49.     public static void main(String argu[]){
  50.         ThreadDeadLock t1 = new ThreadDeadLock();
  51.         ThreadDeadLock t2 = new ThreadDeadLock();
  52.         t1.flag = true;
  53.         t2.flag = false;
  54.         Thread thA = new Thread(t1);
  55.         Thread thB = new Thread(t2);
  56.         thA.start();
  57.         thB.start();
  58.     }
  59. }

程序运行结果：
image.png
以下代码不再执行，程序进入死锁状态。