[Js-Java SE]线程与进程

Posted 2020-10-26 Js_zero

 

线程指的是进程的一个执行场景，也就是执行流程，那么进程和线程有什么区别呢？

　　· 每一个进程是一个应用程序，都有独立的内存空间

　　· 同一个进程中的线程共享进程中的内存和资源（共享的内存是堆内存和方法区内存，栈内存不共享，每个线程有自己的）

5.线程的创建和启动

 1 /*
 2     在Java语言中实现多线程的第一种方式：
 3         第一步：继承java.lang.Thread
 4         第二步：重写run方法
 5 
 6     三个重要知识点：
 7         如何定义线程？
 8         如何创建线程？
 9         如何启动线程？
10 
11 */
12 class ThreadTest02 
13 {
14     public static void main(String[] args) 
15     {
16         // 创建线程
17         Thread t = new Processor();
18         // 启动线程
19         t.start(); // 这段代码执行瞬间结束。告诉JVM分配一个新的栈给t线程
20                     // run不需要程序员手动调用，系统线程启动之后自动调用run方法
21                     // 直接调用run方法会变成直接方法调用，程序只有一个主线程
22 
23         // 这段代码在主线程中运行
24         for (int i = 0; i < 100; i++) {
25             System.out.println("main==>" + i);
26         }
27 
28         // 有了多线程之后，main方法结束只是主线程栈中没有方法栈帧了
29         // 但是其他线程或者其他栈中还有栈帧
30         // main方法结束，程序可能还在运行
31     }
32 }
33 
34 // 定义一个线程
35 class Processor extends Thread
36 {
37     // 重写run方法
38     public void run(){
39         for (int i = 0; i < 100; i++) {
40             System.out.println("run==>" + i);
41         }
42     }
43 }

 1 /*
 2     在Java语言中实现多线程的第二种方式：
 3         第一步：实现java.lang.Runnable接口
 4         第二步：重写run方法
 5 
 6     三个重要知识点：
 7         如何定义线程？
 8         如何创建线程？
 9         如何启动线程？
10 
11 */
12 class ThreadTest03
13 {
14     public static void main(String[] args) 
15     {
16         //创建线程
17         Thread t = new Thread(new Processor());
18 
19         //启动线程
20         t.start();
21     }
22 
23 }
24 
25 // 这种方式是推荐的。因为一个类实现接口之外保留了类的继承
26 class Processor implements Runnable
27 {
28     public void run(){
29         for (int i = 0; i < 10; i++) {
30             System.out.println("run==>" + i);
31         }
32     }
33 }

 

 

6.线程的生命周期

 

新建：采用new语句创建完成

就绪：执行start之后

运行：占用CPU时间

阻塞：执行了wait语句、执行了sleep语句和等待某个对象锁，等待输入的场合

终止： 退出run方法

 

7.线程的调度与控制

　　通常我们的计算机只有一个CPU，CPU在某一个时刻只能执行一条指令，喜爱昵称只有得到CPU时间片，也就是使用权才可以执行指令，在单CPU的机器上线程不是并行运行的，只有在多个CPU上线程才可以并行运行，Java虚拟机要负责线程的调度，取得CPU的使用权，目前有两种调度模型：分时调度模型和抢占式调度模型。Java使用抢占式调度模型

　　分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片

　　抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个。优先级高的线程获取的CPU时间片相对多一些

 8.线程优先级

　　线程的优先级主要分为三种：MAX_PRIORITY（最高级），MIN_PRIORITY（最低级），NORM_PRIORITY（默认标准级别）

 1 /*
 2  * 线程优先级高的获取的CPU时间片相对多一些
 3  * 
 4  * 优先级：1～10
 5  * 最低：1
 6  * 最高：10
 7  * 默认：5
 8  */
 9 public class ThreadTest05 {
10 
11     public static void main(String[] args) {
12         System.out.println(Thread.MAX_PRIORITY); //10
13         System.out.println(Thread.MIN_PRIORITY); //1
14         System.out.println(Thread.NORM_PRIORITY); //5
15         
16         Thread t1 = new Processor();
17         t1.setName("t1");
18 
19         Thread t2 = new Processor();
20         t2.setName("t2");
21 
22         System.out.println(t1.getPriority()); //5
23         System.out.println(t2.getPriority()); //5
24         
25         //设置优先级
26         t1.setPriority(4);
27         t2.setPriority(6);
28         
29         //启动线程
30         t1.start();
31         t2.start();
32     }
33 
34 }
35 
36 class Processor extends Thread {
37 
38     @Override
39     public void run() {
40         for (int i = 0; i < 50; i++) {
41             System.out.println(Thread.currentThread().getName() + "-->" + i);
42         }
43     }
44 
45 }

 

 

9.关于sleep方法需要注意的几点

　　· sleep方法的参数单位为毫秒

　　· sleep方法为静态方法，调用的时候睡眠的是调用了这个方法的线程

　　· 可以使用interrupt方法进行中断，但是interrupt是成员方法（这种方法依靠的是异常处理机制）

　　sleep的终止：

 1 package com.neu.core;
 2 
 3 /*
 4  * 打断线程的第一种方案：利用interrupt方法触发异常处理机制
 5  */
 6 public class ThreadTest08 {
 7     public static void main(String[] args) throws InterruptedException {
 8 
 9         // 创建线程
10         Thread t = new Thread(new Processor());
11         t.setName("t");
12 
13         // 启动线程
14         t.start();
15 
16         // 5秒之后
17         // t.sleep(5000);起到的效果和下面一样，因为sleep方法是静态的
18         Thread.sleep(5000);
19 
20         // 打断t线程的休眠
21         t.interrupt();
22 
23     }
24 }
25 
26 class Processor implements Runnable {
27 
28     @Override
29     public void run() {
30         try {
31             Thread.sleep(5000000000L);
32         } catch (InterruptedException e) {
33             e.printStackTrace();
34         }
35 
36         for (int i = 0; i < 5; i++) {
37             System.out.println(Thread.currentThread().getName() + "-->" + i);
38         }
39     }
40 
41 }
42 /* 运行结果：
43  * ---------- java ----------
44     java.lang.InterruptedException: sleep interrupted
45         at java.lang.Thread.sleep(Native Method)
46         at Processor.run(ThreadTest08.java:29)
47         at java.lang.Thread.run(Thread.java:748)
48     t-->0
49     t-->1
50     t-->2
51     t-->3
52     t-->4
53     
54     Output completed (5 sec consumed) - Normal Termination
55  * 
56  * */

 

 1 package com.neu;
 2 
 3 /**
 4  * 打断线程的第一种方案：设置标志符
 5  */
 6 public class ThreadTest09 {
 7     public static void main(String[] args) throws InterruptedException {
 8         Processor processor = new Processor();
 9         Thread t = new Thread(processor);
10 
11         t.setName("t");
12 
13         t.start();
14 
15         Thread.sleep(5000);
16 
17         processor.run = false;
18     }
19 }
20 
21 class Processor implements Runnable {
22 
23     boolean run = true;
24 
25     @Override
26     public void run() {
27         for (int i = 0; i < 10; i++) {
28             if (run) {
29                 try {
30                     Thread.sleep(1000);
31                 } catch (InterruptedException e) {
32                     // e.printStackTrace();
33                 }
34                 System.out.println(Thread.currentThread().getName() + "-->" + i);
35             }
36         }
37     }
38 
39 }
40 /**
41  * 运行结果：
42  *
43  * t-->0
44  * t-->1
45  * t-->2
46  * t-->3
47  * t-->4
48  *
49  * Process finished with exit code 0
50  */