Java多线程编程Java多线程技能

Posted 2020-11-02 BigJunOBa

　　一、进程和多线程的概念以及线程的优点

　　打开Windo任务管理器可以看到很多正在运行着的exe程序，完全可以将运行在内存中的exe文件理解成进程，进程是受操作系统管理的基本运行单元。

　　线程可以理解成在进程中独立运行的子任务。比如，QQ.exe运行时就有很多的子任务在同时运行。

　　使用线程，可以最大限度地利用CPU的空闲时间来处理其他的任务，CPU在人物之间不停地切换，由于切换速度非常快，所以人们感觉这些任务似乎在同时运行。也就是说看，可以在同一时间内运行更多不同种类的任务，可以大幅增加CPU的利用率。

　　二、使用多线程

　　一个进程正在运行时至少会有一个线程在运行。

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

　　输出为：main。这里输出的main其实就是一个名称叫做main的线程在执行main()方法中的代码。

　　1.继承Thread类

　　实现多线程编程的方式主要有两种：一种是继承Thread类，另一种是实现Runnable接口。从Thread类的结构来看，Thread类实现了Runnable接口，它们之间具有多台关系。为了支持多继承，完全可以实现Runnable接口的形式，一边实现一边继承。

　　1.1线程的调用的随机性

1 public class MyThread extends Thread {
2     @Override
3     public void run() {
4         super.run();
5         System.out.println("MyThread");
6     }
7 }

 1 package test;
 2 
 3 import com.mythread.www.MyThread;
 4 
 5 public class Run {
 6 
 7     public static void main(String[] args) {
 8         MyThread mythread = new MyThread();
 9         mythread.start();
10         System.out.println("运行结束");
11     }
12 
13 }

运行结束
MyThread

 　　从输出结果可以看出，代码的运行结果与代码执行顺序或调用顺序是无关的，线程是一个子任务，CPU以不确定的方式，或者说是以随机的时间来调用线程中的run方法。

　　1.2 演示线程的随机性

 1 package mythread;
 2 
 3 public class MyThread extends Thread {
 4     @Override
 5     public void 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 package test;
 2 
 3 import mythread.MyThread;
 4 
 5 public class Test {
 6     public static void main(String[] args) {
 7         try {
 8 
 9             MyThread thread = new MyThread();
10             thread.setName("myThread");
11             thread.start();
12 
13             for (int i = 0; i < 10; i++) {
14                 int time = (int) (Math.random() * 1000);
15                 Thread.sleep(time);
16                 System.out.println("main=" + Thread.currentThread().getName());
17             }
18         } catch (InterruptedException e) {
19             e.printStackTrace();
20         }
21     }
22 }

main=main
main=main
run=myThread
main=main
run=myThread
run=myThread
main=main
main=main
run=myThread
main=main
main=main
run=myThread
main=main
main=main
run=myThread
run=myThread
run=myThread
main=main
run=myThread
run=myThread

 　　从输出的20个结果可以看出，Thread.java类中的start()方法通知“线程规划器”此线程已经准备就绪，等待调用线程对象的run()方法。这个过程其实就是让系统安排一个时间来调用Thread中的run()方法，也就是使线程得到运行，启动线程，具有异步执行的效果。

　　1.3 同步执行

　　如果调用thread.run()方法就不是异步执行了，而是同步，那么此线程对象并不交给“线程规划器”来进行处理，而是由main主线程来调用run()方法，也就是必须等run()方法中的代码执行完后才可以执行后面的代码。

 1 package extthread;
 2 
 3 public class MyThread extends Thread {
 4 
 5     private int i;
 6 
 7     public MyThread(int i) {
 8         super();
 9         this.i = i;
10     }
11 
12     @Override
13     public void run() {
14         System.out.println(i);
15     }
16 
17 }

 1 package test;
 2 
 3 import extthread.MyThread;
 4 
 5 public class Test {
 6 
 7     public static void main(String[] args) {
 8         MyThread t11 = new MyThread(1);
 9         MyThread t12 = new MyThread(2);
10         MyThread t13 = new MyThread(3);
11         MyThread t14 = new MyThread(4);
12         MyThread t15 = new MyThread(5);
13         MyThread t16 = new MyThread(6);
14         MyThread t17 = new MyThread(7);
15         MyThread t18 = new MyThread(8);
16         MyThread t19 = new MyThread(9);
17         MyThread t110 = new MyThread(10);
18         MyThread t111 = new MyThread(11);
19         MyThread t112 = new MyThread(12);
20         MyThread t113 = new MyThread(13);
21 
22         t11.start();
23         t12.start();
24         t13.start();
25         t14.start();
26         t15.start();
27         t16.start();
28         t17.start();
29         t18.start();
30         t19.start();
31         t110.start();
32         t111.start();
33         t112.start();
34         t113.start();
35 
36     }
37 
38 }

2
3
1
4
5
7
6
8
10
9
11
12
13

 　　从输出结果可以看出，start()方法的顺序并不代表线程启动的顺序。

　　2.实现Runnable接口

　　如果想要创建的线程类已经有一个父类了，这时就不能再继承自Thread类了，因为Java不支持多继承，所以就需要实现Runnable接口。

1 package myrunnable;
2 
3 public class MyRunnable implements Runnable {
4     @Override
5     public void run() {
6         System.out.println("myrunnable类中的run!");
7     }
8 }

 1 package test;
 2 
 3 import myrunnable.MyRunnable;
 4 
 5 public class Run {
 6 
 7     public static void main(String[] args) {
 8         Runnable runnable=new MyRunnable();
 9         Thread thread=new Thread(runnable);
10         thread.start();
11         System.out.println("run中的main!");
12     }
13 
14 }

run中的main!
myrunnable类中的run!

 　　Thread.java类的8个构造函数中，有两个可以传递Runnable接口的对象，并且由于Thread类也实现了Runnable接口，所以也就意味着构造函数Thread(Runnable target)不光可以传入Runnable接口的对象， 还可以传入一个Thread类的对象，这样做完全可以将一个Thread对象中的run()方法交由其他的线程进行调用。

　　3.实例变量与线程安全

　　自定义线程类中的实例变量针对其他线程可以有共享与不共享之分。

　　3.1 不共享数据

　　3.2 共享数据

　　4.留意i--与System.out.println()的异常

　　三、currentThread()方法

　　四、isAlive()方法

　　五、sleep()方法

　　六、getId()方法

　　七、停止线程

　　1.停止不了的线程

　　2.判断线程是否是停止状态

　　3.能停止的线程--异常法

　　4.在沉睡中停止

　　5.能停止的线程--暴力停止

　　6.方法stop()与java.lang.ThreadDeath异常

　　7.释放锁的不良后果

　　8.使用return停止线程

　　八、暂停线程

　　1.suspend与resume方法的使用

　　2.suspend与resume方法的缺点--独占

　　3.suspend与resume方法的缺点--不同步

　　九、yield()方法

　　十、线程的优先级

　　1.线程优先级的继承特性

　　2.优先级具有规则性

　　3.优先级具有随机性

　　4.看谁运行得快

　　十一、守护线程