• Java多线程（二）

    目录

    一、线程的使用

    Thread类的有关方法

    线程的调度

    调度策略：

    java的调度方法

    线程的优先级

    线程的优先等级

    如何获取优先级

    线程有关方法及线程优先级练习

    线程的分类

    二、线程的生命周期

     三、线程的同步（一）（线程安全问题）

    使用继承Thread类创建线程的方式（存在线程安全问题）

     使用实现Runnable接口创建线程的方式（存在线程安全问题）

    synchronized的使用方法

    1、同步代码块

    使用同步代码块解决上述线程安全问题

    2、同步方法

    使用同步方法块解决上述线程安全问题

    一、线程的使用

    Thread类的有关方法

    1、start():启动当前线程；调用当前线程的run()方法
2、run():通常需要重写Thread类中的run()方法，建创建的线程执行的操作声明在此方法中
3、currentThread():静态方法，返回执行当前代码的线程
4、getName():获取当前线程的名字
5、setName():设置当前线程的名字
6、yield():释放当前CPU执行权
7、join():在线程A中，调用线程B的join()方法，此时线程A就进入阻塞状态，直到线程B执行完后，线程A才结束阻塞状态
8、stop():强制结束当前线程（已过时）
9、sleep():让当前线程阻塞一段时间（单位：毫秒）
10、isAlive():判断当前线程是否存活

    线程的调度

    调度策略：

    • 时间片

    •  抢占式：优先级高的线程抢占CPU

    java的调度方法

    • 同优先级线程组先进先出队列，使用时间片策略
    • 对高优先级，使用优先调度的抢占式策略

    线程的优先级

    线程的优先等级

    > MAX_PRIORITY：10
> MIN_PRIORITY：1
> NORM_PRIORITY：5--->默认优先级

    如何获取优先级

    > getPriority():获取当前线程的优先级
> setPriority(int newPriority):设置线程的优先级

    说明：优先级高的要先抢占线程的执行权，但只是从概率上讲，优先级高的线程高概率情况下被执行，但并不意味着只有当优先级高的线程执行完以后，低优先级的线程才开始执行

    线程有关方法及线程优先级练习

    1. class ThreadMethod extends Thread{
    2.     @Override
    3.     public void run() {
    4.         for(int i=0;i<=25;i++){
    5.             if(i%2==0){
    6.  
    7.                 try {
    8.                     //阻塞一秒
    9.                     sleep(100);
    10.                 } catch (InterruptedException e) {
    11.                     throw new RuntimeException(e);
    12.                 }
    13.                 System.out.println(getName()+":"+getPriority()+":"+i);
    14.             }
    15.  
    16.             if(i%20==0){
    17.                 this.yield();
    18.             }
    19.  
    20.         }
    21.     }
    22.  
    23.     public ThreadMethod(String name){
    24.         super(name);
    25.     }
    26. }
    27.  
    28.  
    29. public class ThreadMethodTest {
    30.     public static void main(String[] args) {
    31.         ThreadMethod m1=new ThreadMethod("分线程1");
    32. //        m1.setName("线程1");
    33.  
    34.         //设置分线程的优先级
    35.         m1.setPriority(Thread.MAX_PRIORITY);
    36.         m1.start();
    37.  
    38.         //给主线程命名
    39.         Thread.currentThread().setName("主线程");
    40.         //设置主线程优先级
    41.         Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
    42.  
    43.         for(int i=0;i<=25;i++){
    44.             if(i%2==0){
    45.                 System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i);
    46.             }
    47.             if(i==20){
    48.                 try {
    49.                     m1.join();
    50.                 } catch (InterruptedException e) {
    51.                     throw new RuntimeException(e);
    52.                 }
    53.             }
    54.         }
    55.  
    56.     }
    57. }

    运行结果如下：

    线程的分类

    Java中的线程分为两类：一种是守护线程，一种是用户线程。

    它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。

    守护线程是用来服务用户线程的，通过在start()方法前调用 thread.setDaemon(true)可以把一个用户线程变成一个守护线程。

     Java垃圾回收就是一个典型的守护线程。

    若JVM中都是守护线程，当前JVM将退出。

    二、线程的生命周期

    JDK中用Thread.State类定义了线程的几种状态

    要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

    • 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
    • 就绪：当新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时该线程具备了运行条件，只是没分配到CPU资源
    • 运行：当处于就绪状态的线程被调度并获得CPU资源时，便进入运行状态，run()定义了线程的操作和功能
    • 阻塞：在某种特殊情况下，被人认为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态
    • 死亡：线程完成了自己的全部工作或线程被提前强制性的终止或出现异常导致结束

     三、线程的同步（一）（线程安全问题）

    以具体例题来说明线程安全问题

    模拟火车站售票程序，开启三个窗口售票，总票数为100张

    使用继承Thread类创建线程的方式（存在线程安全问题）

    1. public class WindowTest1 {
    2.     public static void main(String[] args) {
    3.         Window w1=new Window();
    4.         Window w2=new Window();
    5.         Window w3=new Window();
    6.         w1.setName("窗口1");
    7.         w2.setName("窗口2");
    8.         w3.setName("窗口3");
    9.         w1.start();
    10.         w2.start();
    11.         w3.start();
    12.  
    13.     }
    14. }
    15.  
    16. class Window extends Thread{
    17.     private static int ticket=100;
    18.  
    19.     @Override
    20.     public void run() {
    21.         while(true){
    22.             if(ticket>0){
    23.                 System.out.println(getName()+"：卖票，票号为："+ticket);
    24.                 ticket--;
    25.             }else{
    26.                 break;
    27.             }
    28.  
    29.         }
    30.     }
    31. }

    部分运行结果：

     使用实现Runnable接口创建线程的方式（存在线程安全问题）

    1. public class WindowTest2 {
    2.     public static void main(String[] args) {
    3.         Window2 w=new Window2();
    4.         Thread thread1 = new Thread(w);
    5.         Thread thread2 = new Thread(w);
    6.         Thread thread3 = new Thread(w);
    7.         thread1.setName("窗口1");
    8.         thread2.setName("窗口2");
    9.         thread3.setName("窗口3");
    10.         thread1.start();
    11.         thread2.start();
    12.         thread3.start();
    13.     }
    14. }
    15.  
    16. class Window2 implements Runnable{
    17.  
    18.     private int ticket=100;
    19.     @Override
    20.     public void run() {
    21.         while(true){
    22.             if(ticket>0){
    23.                 System.out.println(Thread.currentThread().getName()+",卖票，票号为："+ticket);
    24.                 ticket--;
    25.             }else {
    26.                 break;
    27.             }
    28.         }
    29.     }
    30. }

    部分运行结果如下：

     1. 多线程出现了安全问题

    2. 问题的原因： 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有 执行完，另一个线程参与进来执行。导致共享数据的错误。

    3. 解决办法： 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以 参与执行。

    synchronized的使用方法

    java对于多线程的安全问题提供了专业的解决放方式：同步机制

    1、同步代码块

    synchronized(同步监视器){

            //需要被同步的代码；

    }

    说明：

    • 操作共享数据的代码，即为需要被同步的代码 
    • 共享数据：多个线程共同操作的变量
    • 同步监视器，俗称：锁
      • 任何对象都能充当锁
      • 多个线程必须共享同一把锁

    使用同步代码块解决上述线程安全问题

    使用继承Thread类的方式
    1. public class WindowTest1 {
    2.     public static void main(String[] args) {
    3.         Window w1=new Window();
    4.         Window w2=new Window();
    5.         Window w3=new Window();
    6.         w1.setName("窗口1");
    7.         w2.setName("窗口2");
    8.         w3.setName("窗口3");
    9.         w1.start();
    10.         w2.start();
    11.         w3.start();
    12.  
    13.     }
    14. }
    15.  
    16. class Window extends Thread{
    17.     private static int ticket=100;
    18.    private static Object obj1=new Object();
    19.  
    20.     @Override
    21.     public void run() {
    22.         while(true){
    23.             //方式二：synchronized (obj1){
    24.             synchronized (Window.class){
    25.                 //类也是对象 相当于 Class clazz=Window.class
    26.                 //Window.class只会加载一次
    27.                 if(ticket>0){
    28.                     System.out.println(getName()+"：卖票，票号为："+ticket);
    29.                     ticket--;
    30.                 }else{
    31.                     break;
    32.                 }
    33.             }
    34.  
    35.         }
    36.     }
    37. }
    使用实现Runnable接口的方式
    1. public class WindowTest2 {
    2.     public static void main(String[] args) {
    3.         Window2 w=new Window2();
    4.         Thread thread1 = new Thread(w);
    5.         Thread thread2 = new Thread(w);
    6.         Thread thread3 = new Thread(w);
    7.         thread1.setName("窗口1");
    8.         thread2.setName("窗口2");
    9.         thread3.setName("窗口3");
    10.         thread1.start();
    11.         thread2.start();
    12.         thread3.start();
    13.     }
    14. }
    15.  
    16. class Window2 implements Runnable{
    17.     Object obj=new Object();
    18.     private int ticket=100;
    19.     @Override
    20.     public void run() {
    21.         while(true){
    22.            synchronized (this){ //此时的this：唯一的window2的对象  //方式二：synchronized(obj) {
    23.                 if (ticket > 0) {
    24.                     System.out.println(Thread.currentThread().getName() + ",卖票，票号为：" + ticket);
    25.                     ticket--;
    26.                 } else {
    27.                     break;
    28.                 }
    29.             }
    30.         }
    31.     }
    32. }

    2、同步方法

    如果操作共享数据的代码完整的声明在一个方法中，不妨将这个方法声明为同步的

    说明：

    • 同步方法仍然涉及到同步监视器，只是不需要显式的声明
    • 静态同步方法中，同步监视器是：this（默认）
    • 非静态方法中，同步监视器是：当前类本身

    使用同步方法块解决上述线程安全问题

    使用继承Thread类的方式

    1. public class WindowTest1_2 {
    2.     public static void main(String[] args) {
    3.         Window1_2 w1=new Window1_2();
    4.         Window1_2 w2=new Window1_2();
    5.         Window1_2 w3=new Window1_2();
    6.         w1.setName("窗口1");
    7.         w2.setName("窗口2");
    8.         w3.setName("窗口3");
    9.         w1.start();
    10.         w2.start();
    11.         w3.start();
    12.  
    13.     }
    14. }
    15.  
    16. class Window1_2 extends Thread{
    17.     private static int ticket=100;
    18.  
    19.     @Override
    20.     public void run() {
    21.         while(true){
    22.             show();
    23.         }
    24.     }
    25.     private static synchronized void show(){//同步监视器：t1,t2,t3(此种方法是错误的)
    26.         //必须保证此方法是静态的
    27.         //此时的同步监视器：Window1_2
    28.         if(ticket>0){
    29.             System.out.println(Thread.currentThread().getName()+"：卖票，票号为："+ticket);
    30.             ticket--;
    31.         }
    32.     }
    33. }
    34.

    使用实现Runnable接口的方式

    1. public class WindowTest2_2 {
    2.     public static void main(String[] args) {
    3.         Window2_2 w=new Window2_2();
    4.         Thread thread1 = new Thread(w);
    5.         Thread thread2 = new Thread(w);
    6.         Thread thread3 = new Thread(w);
    7.         thread1.setName("窗口1");
    8.         thread2.setName("窗口2");
    9.         thread3.setName("窗口3");
    10.         thread1.start();
    11.         thread2.start();
    12.         thread3.start();
    13.     }
    14. }
    15.  
    16. class Window2_2 implements Runnable{
    17.  
    18.     private int ticket=100;
    19.     @Override
    20.     public void run() {
    21.         while(true){
    22.            show();
    23.         }
    24.     }
    25.     private synchronized void show(){//同步监视器：this
    26.         if(ticket>0){
    27.             System.out.println(Thread.currentThread().getName()+",卖票，票号为："+ticket);
    28.             ticket--;
    29.         }
    30.     }
    31. }

  • 相关阅读:
    JVM学习第一天
    PhpStorm
    MariaDB Tutorial
    高科技案例研究微软设备事业部 | 达索系统百世慧®
    互联网大厂技术岗实习/求职经验分享（实习内推+简历+面试+offer）
    操作系统-进程与线程（调度器与闲逛进程，调度算法与评价标准）
    查看windows后台进程命令行参数
    《嵌入式虚拟化技术与应用》：深入浅出阐述嵌入式虚拟机原理，实现“小而能”嵌入式虚拟机！
    人脸识别相关代码
    【Python】 - Python的内置函数isinstance()中的参数classinfo一共有多少种，可以判断多少种类型？
  • 原文地址：https://blog.csdn.net/zssxcj/article/details/127977058