Java多线程技能

悠悠 2023-08-17 17:31 230阅读 0赞

下面进入Java多线程的学习，首先介绍Thread类的核心方法

* 线程的启动

* 线程的暂停 　　

* 线程停止

* 线程的优先级

* 线程安全的相关问题

一、进程

要学习多线程就不得不提到进程，进程是什么，当我们打开windows系统的任务管理器里面运行着的.exe文件可以被看作是一个个进程。进程是受操作系统管理的基本运行单元。

1135822-20190820173803186-1845020932.png

那什么是线程呢？

线程是进程中独立运行的子任务。比如QQ.exe运行时有很多的子任务在运行，发QQ消息，下载文件，视频电话等，他们每一个任务可以看做一个线程在工作。这样做的优点是什么呢？可以最大限度的利用CPU空闲的时间去处理其他任务。 CPU不停地在这些任务之间切换，由于切换的速度非常快，给用户的感觉就像是几个任务在同时运行。所以使用多线程技术后，可以在同一时间内运行更多不同种类的任务。为了更好的了解多线程的优点我们可以看下图 ，了解一下单任务的缺点。

1135822-20190821100750051-1356204369.png

在图1-3中，任务1和任务2是单独运行的，互不相关的任务。任务1是在等待远程的服务器返回数据，以便进行后期的处理，这时的CPU一直处在等待的状态下一直闲在那里。虽然任务2 的运行时间只有1秒，但是必须要等待任务1 运行完了之后10秒后才能运行任务2 ，那么他们花费的总时间就是11秒。本程序是在单任务运行环境中，所以任务2 有非常长时间的等待，系统运行效率大幅降低。单任务的特点就是排队执行，也就是同步。这样会导致CPU的利用率大幅降低。

在图1-4中是多任务的运行环境下，CPU可以在任务1 和任务2 中任意切换，使得任务2 不必等到10秒之后再运行，运行的效率大大提升。

这就是要是用的多线程技术也就是我们要学习多线程的原因。这是多线程的优点，使用多线程也就是在使用异步。

注意 ：多线程是异步的，千万不要把编译工具中代码的顺序当成线程执行的顺序，线程被调用的时机是随机的。

二、使用多线程。

一个进程在运行时至少有一个线程在运行，这种情况在Java中也是存在的。这些线程在后台默默的执行，比如说调用public static void main(String[] args)main方法的线程就是这样的，而且他是由jvm创建的。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         System.out.println(Thread.currentThread().getName());
  4.         System.out.println(Thread.currentThread().getId());
  5.     }
  6. }

程序运行结果

1135822-20190821103708122-652374019.png

控制台输出的main其实上就是一个名称叫做main的线程在执行main（）方法中的代码。在这里说明：控制台输出的main和main（）方法没有任何的关系，只是名字相同而已。

创建多线程的方法：

在Java JDK中已经自带了对多线程技术的支持，可以很方便的进行多线程的编程。实现多线程的方法主要有两种,一一种是继承Thread类，一种是实现Runable接口。

2.1 我们先看继承Thread类。首先我们先了解一下Thread 类的结构。

1135822-20190821104641461-1406548774.png

从上源代码可以看出Thread类继承了Runable接口，他们之间具有多态关系。

我们现在来创建一个类MyThread 继承Thread类，并且重写run（）方法，在run（）方法中写线程要执行任务的代码。

  1. public class MyThread extends Thread  {
  2.     @Override
  3.     public void run() {
  4.         super.run();
  5.         //在run（）方法中写线程要执行任务的代码
  6.         System.out.println("MyThread");
  7.     }
  8. }

写运行线程的代码：

  1. public class MyThreadTest  {
  2.     public static void main(String[] args) {
  3.         MyThread myThread =new MyThread();
  4.         myThread.start();
  5.         System.out.println("运行结束。。");
  6.     }
  7. }

运行结果:

1135822-20190821140637779-44048630.png

根据运行的结果，我们发现MyThread.java 中的run（）方法执行的时间比较晚，这也说明在使用多线程技术的时候，代码的运行结果与代码的执行顺序或调用顺序无关。

线程是一个子任务，CPU以随机的时间来调用线程中的run（）方法，所以就会出现“运行结束”早输出，“MyThread”后输出的结果。

注意 ：如果多次调用start（）方法就会出现异常： Exception in thread “main” java.lang.IllegalThreadStateException。

1135822-20190821141530351-454721556.png1135822-20190821141544556-2048969603.png

上面介绍了线程的调用是随机的，那么现在我们来演示一下线程的随机性。

  1. public class MyThread extends Thread  {
  2.     @Override
  3.     public void run() {
  4.         super.run();
  5.         //在run（）方法中写线程要执行任务的代码
  6.         try {
  7.         for (int i =0;i<10;i++){
  8.             int  time = (int)Math.random() * 1000;
  9.                 Thread.sleep(time);
  10.             System.out.println("run :"+Thread.currentThread().getName());
  11.         }
  12.         } catch (InterruptedException e) {
  13.             e.printStackTrace();
  14.         }
  15.     }
  16. }

创建运行类;

  1. public class MyThreadTest  {
  2.     public static void main(String[] args) {
  3.         try {
  4.         MyThread myThread =new MyThread();
  5.         myThread.setName("myThread");
  6.         myThread.start();
  7.         for (int i = 0;i<10 ;i++){
  8.           int time  =(int) Math.random()*1000;
  9.             Thread.sleep(time);
  10.             System.out.println("main : "+Thread.currentThread().getName());
  11.         }
  12.         } catch (InterruptedException e) {
  13.             e.printStackTrace();
  14.         }
  15.     }
  16. }

运行的结果：

1135822-20190821143006139-1010431293.png

在代码中使用随机数的形式使线程达到挂起的效果，从而表现CPU执行哪个线程具有不确定性。

Thread.java 类中的start()方法通知“线程规划器”此线程准备好了，等待调用线程对象的run（）方法。这个过程就是让系统安排个时间去调用Thread类的run（）方法，就是使线程得到运行，启动线程，具有异步执行的效果。如果调用Thread类的run（）方法就不是异步而是同步。那此线程对象就不是交给线程规划器来进行处理，而是有main主线程来调用run（）方法，需等到run（）方法中的代码执行完之后才能执行后面的代码。

另外注意一点：执行start（）方法的顺序不代表线程启动的顺序。

  1. package Test;
  3. public class MyThread3 extends Thread {
  4.     private int i;
  6.     public MyThread3(int i) {
  7.         super();
  8.         this.i = i;
  9.     }
  11.     @Override
  12.     public void run( ) {
  13.         super.run();
  14.         System.out.println(i);
  15.     }
  16. }
  18. package Test;
  20. public class MyThread3Test {
  21.     public static void main(String[] args) {
  22.          MyThread3 t1 =new MyThread3(1);
  23.          MyThread3 t2 =new MyThread3(2);
  24.          MyThread3 t3 =new MyThread3(3);
  25.          MyThread3 t4 =new MyThread3(4);
  26.          MyThread3 t5 =new MyThread3(5);
  27.          MyThread3 t6 =new MyThread3(6);
  28.          MyThread3 t7 =new MyThread3(7);
  29.          MyThread3 t8 =new MyThread3(8);
  30.          MyThread3 t9 =new MyThread3(9);
  31.          MyThread3 t10 =new MyThread3(10);
  32.          MyThread3 t11 =new MyThread3(11);
  33.          MyThread3 t12 =new MyThread3(12);
  34.          MyThread3 t13 =new MyThread3(13);
  35.          MyThread3 t14 =new MyThread3(14);
  36.          MyThread3 t15 =new MyThread3(15);
  37.          t1.start();
  38.          t2.start();
  39.          t3.start();
  40.          t4.start();
  41.          t5.start();
  42.          t6.start();
  43.          t7.start();
  44.          t8.start();
  45.          t9.start();
  46.          t10.start();
  47.          t11.start();
  48.          t12.start();
  49.          t13.start();
  50.          t14.start();
  51.          t15.start();
  52.     }
  53. }

运行结果：

1135822-20190822145123591-1847718588.png

程序运行后如上图所示。

2.2 下面是线程的另外一种实现的方法：实现Runable接口。

如果我们想创建一个线程但是他已经有了父类，就不能再继承Thread类了，因为Java不支持多继承，这时就可以用实现Runable接口的方法来应对。

首先我们看一个用Runable接口实现的线程的示例代码：

  1. package runableTest;
  3. public class MyRunable implements Runnable {
  4.     @Override
  5.     public void run() {
  6.         System.out.println("运行中。。。");
  7.     }
  8. }
  10. package runableTest;
  12. public class Test {
  13.     public static void main(String[] args) {
  14.         MyRunable my = new MyRunable();
  15.          Thread t =new Thread(my);
  16.          t.start();
  17.     }
  18. }

为什么我们要这样写他的测试类呢。在下图Thread类的构造函数中，可以看到有两个是包含Runable接口的。说明构造函数支持传入Runable的对象。

1135822-20190826144153304-2098406214.png

运行结果：

1135822-20190826144943482-1158412495.png

使用继承Thread.java 的方式来开发多线程应用程序在设计上是具有局限性的，因为Java支持单继承，多实现。为了改变这种限制我们可以使用实现Runable接口的方式实现多线程。

另外Thread.java 类底层也是实现了Runable接口。

1135822-20190826145535753-1389970727.png

这也就意味着Thread类的构造函数不仅可以传入Runable接口对象，还可以传入Thread类的对象，这样做可以将Thread类的Run（）方法交由其他线程来调用。

2.3 实例变量与线程安全

自定义的线程中的实例变量与其他线程有共享与不共享之分，这在多线程交互时是很重要的技术。

（1）不共享数据的情况

1135822-20190826150510711-2098416290.png

通过实例看不共享数据情况：

  1. package Test.共享;
  3. public class MyThread extends Thread {
  4.     int count = 5;
  6.     public MyThread(String name) {
  7.         super(name);
  8.         setName(name);
  9.     }
  11.     @Override
  12.     public void run() {
  13.         super.run();
  14.         while(count >0){
  15.             count--;
  16.             System.out.println("由"+Thread.currentThread().getName()+"计算 ："+count);
  17.         }
  19.     }
  20. }
  22. package Test.共享;
  24. public class Test {
  25.     public static void main(String[] args) {
  26.         MyThread m1 = new MyThread("A");
  27.         MyThread m2 = new MyThread("B");
  28.         MyThread m3 = new MyThread("C");
  29.         m1.start();
  30.         m2.start();
  31.         m3.start();
  32.     }
  33. }

运行结果：

1135822-20190826151548980-1711371285.png

线程不共享的情况中：我们创建了三个线程，每个线程都有各自的count变量，每个线程各自减少各自的count变量的值。

如果我们想让三个线程共同减少一个变量时，这种情况就是线程共享。

线程共享的情况;如图

1135822-20190826152119158-206106304.png

比如投票时，就可以实现多线程可以同时处理同一个人的票数。

  1. package Test.共享;
  3. public class MyThread1 extends Thread {
  4. private int count = 5; 
  5.     @Override
  6.     public void run() {
  7.         super.run();
  8.         count--;
  9.         System.out.println("由"+Thread.currentThread().getName()+"计算 ："+count);
  10.     }
  11. }
  13. package Test.共享;
  15. public class Test1 {
  16.     public static void main(String[] args) {
  17.         MyThread1 thread =new MyThread1();
  18.          Thread a =new Thread(thread,"A");
  19.          Thread b =new Thread(thread,"B");
  20.          Thread c =new Thread(thread,"C");
  21.          Thread d =new Thread(thread,"D");
  22.          Thread e =new Thread(thread,"E");
  23.          a.start();
  24.          b.start();
  25.          c.start();
  26.          d.start();
  27.          e.start();
  29.     }
  30. }
  32. package Test.共享;
  34. public class Test1 {
  35.     public static void main(String[] args) {
  36.         MyThread1 thread =new MyThread1();
  37.          Thread a =new Thread(thread,"A");
  38.          Thread b =new Thread(thread,"B");
  39.          Thread c =new Thread(thread,"C");
  40.          Thread d =new Thread(thread,"D");
  41.          Thread e =new Thread(thread,"E");
  42.          a.start();
  43.          b.start();
  44.          c.start();
  45.          d.start();
  46.          e.start();
  48.     }
  49. }

运行结果：

1135822-20190826153244307-1389081827.png

如运行结果所示，线程A和线程B打印出的值都是3，说明A和B同时对Count进行处理，产生了“非线程安全”的问题。而我们想要得到的打印结果是依次递减的。

在某些jvm中，i—的操作要分为3步：

  1. 取得原有i值.

2.计算i-1.

3.对i进行赋值。

在这3个步骤中，如果有多个线程同时访问，那移动会出现非线程安全问题。

这就是典型的销售场景。五个销售点同时出售火车票的问题。每一个销售员卖掉一张票之后，不可以得到相同的剩余数量。每个销售员卖出票进行减一操作后，其他销售员才可以在剩余的票数进行减一。这就需要使多个线程之间进行同步，也就是按顺序排队的方式进行减一的操作。更改代码。

  1. package Test.共享;
  3. public class MyThread1 extends Thread {
  4. private int count = 5;
  5.     @Override
  6.    synchronized public void run() {
  7.         super.run();
  8.         count--;
  9.         System.out.println("由"+Thread.currentThread().getName()+"计算 ："+count);
  10.     }
  11. }

重新运行就不会出现count值相同的情况：

1135822-20190826154906085-2104011514.png

在run（）方法前加上synchronized关键字，使多个线程在执行run（）方法时，以排队的方式进行处理。当一个线程调用run（）前首先判断run（）有没有被上锁。如果上锁说明正有其他线程调用run方法，需要等到run方法调用结束之后其他线程才可调用，这样实现了线程排队调用run方法，也达到了按顺序count值减一的效果。synchronized可以在任意方法，对象上加锁，而加锁的这段代码被称为“互斥区”或“临界区”。

当一个线程想要执行同步方法里的代码时，线程首先去尝试拿这把锁，如果可以拿到，这个线程就可以执行synchronized里面的代码，如果不能拿到这把锁，这个线程将不断的尝试去拿这把锁，直到拿到为止。同时还会有多个线程去争抢这把锁。

本节中出现了一个术语“非线程安全”。非线程安全主要是指多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改，值不同步的情况，进而影响程序的执行流程。接下来学习如何解决“非线程安全”问题。

现在我们创建一个非线程安全的环境。

  1. package Test.线程安全;
  3. public class LoginServlet {
  4.     private static String usernameRef;
  5.     private static String passwordRef;
  6.     public static void doPost(String username,String password)   {
  7.             try {
  8.                 usernameRef = username;
  9.                 if (username.equals("kitty")) {
  10.                     Thread.sleep(5000);
  11.                 }
  12.                 passwordRef = password;
  13.                 System.out.println("username :"+usernameRef  + " password  :"+passwordRef);
  14.             } catch (InterruptedException e) {
  15.                 e.printStackTrace();
  16.             }
  17.         }
  19.     }
  21. package Test.线程安全;
  23. public class ALogin extends Thread  {
  24.     @Override
  25.     public void run() {
  26.          LoginServlet.doPost("kitty","Dai15713131313131");
  27.     }
  28. }
  30. package Test.线程安全;
  32. public class BLogin extends Thread  {
  33.     @Override
  34.     public void run() {
  35.          LoginServlet.doPost("guohang","guohang5212521521");
  36.     }
  37. }
  39. package Test.线程安全;
  41. public class Run {
  42.     public static void main(String[] args) {
  43.         ALogin a =new ALogin();
  44.         BLogin b =new BLogin();
  45.         a.start();
  46.         b.start();
  47.     }
  48. }

运行结果：

1135822-20190826171955390-1311339714.png

这样我们可以看出，发生了线程安全的问题，那么结果“非线程安全”的方法也是加上synchronized关键字，更改代码如下：

  1. package Test.线程安全;
  3. public class LoginServlet {
  4.     private static String usernameRef;
  5.     private static String passwordRef;
  6.     synchronized public static void doPost(String username,String password)   {
  7.             try {
  8.                 usernameRef = username;
  9.                 if (username.equals("kitty")) {
  10.                     Thread.sleep(5000);
  11.                 }
  12.                 passwordRef = password;
  13.                 System.out.println("username :"+usernameRef  + " password  :"+passwordRef);
  14.             } catch (InterruptedException e) {
  15.                 e.printStackTrace();
  16.             }
  17.         }
  19.     }

运行结果：

1135822-20190826172525049-63581089.png

2.4 留意 i— 与System.out.println() 的异常。

在前面章节中，我们解决了非线程安全的时候使用synchronized关键字，接下来通过案例细化一下println()方法和 i++ 联合使用的时候有可能出现的另外一种异常。

1135822-20190826173922108-119480317.png

  1. package Test.samesnm;
  3. public class MyThread extends Thread {
  4.     private int i = 5;
  5.     @Override
  6.     public void run() {
  7.         System.out.println("i="+ (i--)+"threadName"+Thread.currentThread().getName());
  8.     }
  9. }
  11. package Test.samesnm;
  13. public class Test {
  14.     public static void main(String[] args) {
  15.          MyThread run =new MyThread();
  16.          Thread t1 =new Thread(run);
  17.          Thread t2 =new Thread(run);
  18.          Thread t3 =new Thread(run);
  19.          Thread t4 =new Thread(run);
  20.          Thread t5 =new Thread(run);
  22.          t1.start();
  23.          t2.start();
  24.          t3.start();
  25.          t4.start();
  26.          t5.start();
  27.     }
  28. }

1135822-20190826174041329-1089350142.png

运行结果：

1135822-20190826173836503-1934237033.png

本实验的目的是：虽然你println()方法在内部是同步的，但i—的操作确实在进入println()之前发生的，所以有发生非线程安全问题的概率。

1135822-20190826175116894-1515590414.png

所以，为了防止发生非线程安全的问题，还是一年继续使用同步方法。

  1. package Test.samesnm;
  3. public class MyThread extends Thread {
  4.     private int i = 5;
  5.     @Override
  6.      synchronized  public void run() {
  7.         System.out.println("i="+ (i--)+"threadName"+Thread.currentThread().getName());
  8.     }
  9. }

三 、currentThread()方法

  1. currentThread()方法可返回代码段正在被哪个线程调用的信息。通过下面的事例代码说明:
  3. package Test.currentThread方法;
  5. public class Run1 {
  6.     public static void main(String[] args) {
  7.         System.out.println(Thread.currentThread().getName());
  8.     }
  9. }

运行结果：

1135822-20190827100508098-1932070892.png

结果说明：main（）方法是被名为main的线程调用。

继续

  1. package Test.currentThread方法;
  3. public class MyThread extends Thread{
  4.     public MyThread() {
  5.         System.out.println("构造方法的打印 ："+Thread.currentThread().getName());
  6.     }
  8.     @Override
  9.     public void run() {
  10.         super.run();
  11.         System.out.println("run 方法的打印 ："+Thread.currentThread().getName());
  12.     }
  13. }
  15. package Test.currentThread方法;
  17. public class Run2 {
  18.     public static void main(String[] args) {
  19.         MyThread t =new MyThread();
  20.         t.start();
  21.     }
  22. }

运行结果：

1135822-20190827101019032-1808393307.png

由上运行结果可以发现，MyThread.java 类的构造函数是被main线程调用的，而run方法是被名为Thread-0的线程调用的，run方法是自动调用的方法。

更改Run2.java 的代码

1135822-20190827101156367-425274145.png

构造方法 和 run 方法 均被main主线程所调用。

继续测试;

  1. package Test.currentThread方法;
  3. public class CountOperate extends Thread {
  5.     public CountOperate() {
  6.         System.out.println("CountOperate ---- begin--");
  7.         System.out.println("Thread.currentThread().getName() = "+Thread.currentThread().getName());
  8.         System.out.println("this.name = "+this.getName());
  9.         System.out.println("CountOperate ---- end--");
  10.     }
  12.     @Override
  13.     public void run() {
  14.         System.out.println("run ---- begin--");
  15.         System.out.println("Thread.currentThread().getName() = "+Thread.currentThread().getName());
  16.         System.out.println("this.name = "+this.getName());
  17.         System.out.println("run ---- end--");
  18.     }
  19. }
  21. package Test.currentThread方法;
  23. public class CountOperateTest {
  24.     public static void main(String[] args) {
  26.         CountOperate countOperate =new CountOperate();
  27.         Thread thread =new Thread(countOperate);
  28.         thread.setName("kitty");
  29.         thread.start();
  30.     }
  31. }

运行结果：

1135822-20190827103059875-1104028540.png

四、isAive()方法

方法isAive()判断当前线程是否处于活动状态。

  1. package Test.isAive方法;
  3. public class MyThread extends Thread {
  4.     @Override
  5.     public void run() {
  6.         System.out.println("run ="+this.isAlive());
  7.     }
  8. }
  10. package Test.isAive方法;
  12. public class MythreadTest {
  13.     public static void main(String[] args) {
  14.         MyThread t =new MyThread();
  15.         System.out.println("begin =="+t.isAlive());
  16.         t.start();
  17.         System.out.println("end =="+t.isAlive());
  18.     }
  19. }

运行结果：

1135822-20190827103908882-2026822136.png

方法isAIve（）是测试线程是否处在活动状态。什么是活动状态呢。就是线程已经启动且尚未终止。线程处在正在运行或者是准备开始运行的状态，就认为线程是存活的。

1135822-20190827104310338-1334632441.png

虽然这里输出的结果是true但是这个值是不确定的，输出true是因为线程还没有执行完毕。更改代码 。

  1. package Test.isAive方法;
  3. public class MythreadTest {
  4.     public static void main(String[] args) {
  5.         try {
  6.             MyThread t =new MyThread();
  7.             System.out.println("begin =="+t.isAlive());
  8.             t.start();
  9.             Thread.sleep(1000);
  10.             System.out.println("end =="+t.isAlive());
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  15.     }
  16. }

则输出的结果为：false，因为线程t 在一秒内已经执行完毕。

1135822-20190827104817838-403560283.png

另外，在使用isAlive()方法时，如果将线程对象以构造函数的方法传递给Thread对象进行Start（）启动时，运行结果和前面事例是有差异的。造成这样的原因是来自于Thread.currentThread()和this的差异。

  1. package Test.isAive方法;
  3. public class CountOperateA extends Thread {
  5.     public CountOperateA() {
  6.         System.out.println("CountOperateA ---- begin--");
  7.         System.out.println("CountOperateA -- Thread.currentThread().getName() = "+Thread.currentThread().getName());
  8.         System.out.println("CountOperateA--- this.name = "+this.getName());
  9.         System.out.println("CountOperateA---Thread.currentThread().isAlive() = "+Thread.currentThread().isAlive());
  10.         System.out.println("CountOperateA----this.isAive = "+this.isAlive());
  11.         System.out.println("CountOperateA ---- end--");
  12.     }
  14.     @Override
  15.     public void run() {
  16.         System.out.println("run ---- begin--");
  17.         System.out.println("run === Thread.currentThread().getName() = "+Thread.currentThread().getName());
  18.         System.out.println("run ===this.name = "+this.getName());
  19.         System.out.println("run ===Thread.currentThread().isAlive() = "+Thread.currentThread().isAlive());
  20.         System.out.println("run === this.isAive = "+this.isAlive());
  21.         System.out.println("run ---- end--");
  22.     }
  23. }
  25. package Test.isAive方法;
  27. import Test.currentThread方法.CountOperate;
  29. public class CountOperateTest {
  30.     public static void main(String[] args) {
  31.         CountOperateA countOperate =new CountOperateA();
  32.         Thread thread =new Thread(countOperate);
  33.         thread.setName("kitty");
  34.         System.out.println("main begin==== isAive : "+Thread.currentThread().isAlive());
  35.         thread.start();
  36.         System.out.println("main end==== isAive : "+Thread.currentThread().isAlive());
  37.     }
  38. }

运行结果：

1135822-20190827111219950-1215401862.png

五、sleep（）方法。

1135822-20190827135624881-507860662.png

方法sleep()的作用是在指定的秒数内让当前“正在执行的线程”休眠（暂停执行），这个“正在执行的线程”是指this.currentThread（）返回的线程。

  1. package Test.sleepff;
  3. public class MyThread extends Thread{
  4.     @Override
  5.     public void run() {
  6.         try {
  7.             System.out.println("run  threadname  "+this.currentThread().getName()+" begin");
  8.             Thread.sleep(2000);
  9.             System.out.println("run  threadname  "+this.currentThread().getName()+" end");
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.     }
  14. }
  16. package Test.sleepff;
  18. public class Test {
  19.     public static void main(String[] args) {
  20.         MyThread myThread = new MyThread();
  21.         System.out.println("begin " + System.currentTimeMillis());
  22.         myThread.run();
  23.         System.out.println("end " + System.currentTimeMillis());
  24.     }
  25. }

直接调用run（）方法程序运行结果：

1135822-20190827141042209-654957578.png

创建一个新的MyThread2.Java

  1. package Test.sleepff;
  3. public class MyThread2 extends Thread{
  4.     @Override
  5.     public void run() {
  6.         try {
  7.             System.out.println("run  threadname  "+this.currentThread().getName()+" begin = "+System.currentTimeMillis());
  8.             Thread.sleep(2000);
  9.             System.out.println("run  threadname  "+this.currentThread().getName()+" end = "+System.currentTimeMillis());
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.     }
  14. }
  16. package Test.sleepff;
  18. public class Test2 {
  19.     public static void main(String[] args) {
  20.         MyThread2 myThread = new MyThread2();
  21.         System.out.println("begin " + System.currentTimeMillis());
  22.         myThread.start();
  23.         System.out.println("end " + System.currentTimeMillis());
  24.     }
  25. }

运行结果：

1135822-20190827141441825-1172527585.png

由于main线程与Mythread2线程是异步执行的，所以首先打印的信息是begin和end。而MyThread2线程是随后运行的，在最后两行打印run begin和run end 的信息。

六、getId()方法。

1135822-20190827142903657-1831560223.png

  1. package Test.getIdff;
  3. public class MyThreadTest{
  4.     public static void main(String[] args) {
  5.         System.out.println(Thread.currentThread().getName()+"  "+Thread.currentThread().getId());
  6.     }
  7. }

1135822-20190827142841194-1348503026.png

1135822-20190827142926631-1055791293.png

七、停止线程。

  1.      停止线程是在多线程开发时很重要的技术点，掌握此技术可以对线程的停止进行有效的处理。使用Java内置支持多线程的类设计多线程应用是很常见的事情，但是如果处理不好就会导致超出预期的行为并且难以定位错误。本节讨论如何更好的停止一个线程。停止一个线程意味着在线程在处理完任务之前停掉正在做的操作，也就是放弃当前的操作。虽然这看起来非常简单，但是必须做好防范措施，以便达到预期的效果。停止一个线程可以使用Thread.stop()方法，但是最好不使用他，虽然他确实可以停止一个正在运行的线程，但是这个方法是不安全的，而且是已经被废弃的，在将来的Java版本中，这个方法将不可用活不被支持。

大多数停止一个线程的操作使用Thread.interupt（）,尽管方法的名称是“停止，中止”的意思，但是这个方法不会中止一个正在运行的线程，还需要加入一个判断才可以完成线程的停止。

1）使用退出标志，使线程正常退出，也就是当run（）方法完成后线程中止。

2）使用stop方法强行终止线程，但是不推荐，因为stop和suspend及resume一样，都是作废过期的方法，使用他们可能产生不可预期的结果。

3）使用interupt方法中断线程。

这3个方法会在后面的章节进行介绍。

7.1 停止不了的线程

调用interrupt（）方法来停止线程，但是interrupt（）方法的使用效果并不像for+break语句那样，马上就停止循环。调用interrupt（）方法仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程。

  1. package Test.stop;
  3. public class MyThread extends Thread {
  4.     @Override
  5.     public void run() {
  6.          for (int i =0;i<5000;i++){
  7.              System.out.println("i = "+(i+1));
  8.          }
  9.     }
  10. }
  12. package Test.stop;
  14. public class Test {
  15.     public static void main(String[] args) {
  16.         try {
  17.             MyThread thread =new MyThread();
  18.             thread.start();
  19.             Thread.sleep(2000);
  20.             thread.interrupt();
  21.         } catch (InterruptedException e) {
  22.             e.printStackTrace();
  23.         }
  24.     }
  25. }

1135822-20190827150819977-2023074700.png

从运行结果看来interrupt（）并没有停止线程。

7.2 判断线程是否是停止状态。

转载于:https://www.cnblogs.com/cuixiaomeng/p/11384234.html

发表评论

表情：
评论列表 （有 0 条评论，230人围观）

还没有评论，来说两句吧...

相关阅读