多线程之属性、中断、状态、安全

查看线程的一些属性

public class ThreadDemo12 {     public static void main(String[] args) {         Thread t1 = new Thread(()->{             try {                 Thread.sleep(1000);             } catch (InterruptedException e) {                 e.printStackTrace();             }         },"张三");         System.out.println("t1的线程状态"+t1.getState());         t1.start();         System.out.println("t1的线程id:"+t1.getId());         System.out.println("t1的线程名称:"+t1.getName());         System.out.println("t1的线程优先级:"+t1.getPriority());         System.out.println("t1是否为后台线程:"+t1.isDaemon());         System.out.println("t1线程是否存活:"+t1.isAlive());         System.out.println("t1线程是否被终端:"+t1.isInterrupted());     } } 

执行结果:
多线程之属性、中断、状态、安全

start和run的区别

1、run属于普通方法,start属于启动线程的方法
2、run方法可以执行多次,start只能执行一次

线程中断

1、使用全局自定义的变量终止线程

/**  * 使用全局自定义来终止线程  */ public class ThreadDemo16 {     //全局自定义变量     private static boolean flag = false;      public static void main(String[] args) throws InterruptedException {         Thread t1 = new Thread(new Runnable() {             @Override             public void run() {                 while (!flag){                     try {                         Thread.sleep(100);                     } catch (InterruptedException e) {                         e.printStackTrace();                     }                     System.out.println("我正在转账");                 }                 System.out.println("转账终止");             }         });         t1.start();          Thread t2 = new Thread(new Runnable() {             @Override             public void run() {                 try {                     Thread.sleep(310);                 } catch (InterruptedException e) {                      e.printStackTrace();                  }                 //改变变量的状态来终止线程的执行                 System.out.println("停止交易有内鬼");                 flag=true;              }         });         t2.start();          t1.join();         t2.join();     } } 

执行结果:
多线程之属性、中断、状态、安全
注意:这种方法执行的时候比较温和,当它在收到终止指令之后,需要执行完当前的任务才会停止。

2、使用线程提供的终止方法interrupt()方法

/**  * 使用interrupt终止线程  */ public class ThreadDemo17 {     public static void main(String[] args) throws InterruptedException {         //创建线程         Thread t1 = new Thread(new Runnable() {             @Override             public void run() {                 while (!Thread.interrupted()){  //会复位线程的终止状态 执行判断线程终止为true后会将状态重置为false                 // while(!Thread.currentThread().isInterrupted()) 不会复位线程的终止状态                     try {                         Thread.sleep(100);                     } catch (InterruptedException e) {                         e.printStackTrace();                         break;                     }                     System.out.println("别烦我,我正在转账");                 }                 System.out.println("终止线程");             }         });         t1.start();           Thread.sleep(310);         //终止线程         System.out.println("有内鬼停止交易");         t1.interrupt();     } }  

执行结果:
多线程之属性、中断、状态、安全
注意:这种方法会在收到终止指令后立马结束执行。

3、使用线程提供的方法stop来终止线程
这种方法就不用了了,因为它终止线程之后不会释放资源

线程的状态

1、NEW:新建状态,没有调用start之前
2、RUNNABLE:运行状态,Running执行中,Ready就绪
3、BLOCKED:阻塞状态,多个线程并发试图获取同一把锁
4、WAITING:等待状态,没有明确的等待结束时间(wait())
5、TIMED_WAITING:超时等待状态,有明确的等待时间
6、TERMINATED:终止状态

yiled()方法

出让CPU执行权
特点:不一定能正常出让CPU的执行权

public class ThreadDemo22 {     private static final int maxSize = 1000;     public static void main(String[] args) {         Thread t1 = new Thread(new Runnable() {             @Override             public void run() {                 for (int i = 0; i <maxSize ; i++) {                     //出让cpu的执行权                    Thread.yield();                     System.out.println("我是t1");                 }             }         },"t1");         t1.start();          Thread t2 = new Thread(new Runnable() {             @Override             public void run() {                 for (int i = 0; i <maxSize ; i++) {                     System.out.println("我是t2");                 }             }         });         t2.start();     } } 

线程安全

线程安全:多线程执行中,执行的结果和预期相符就叫做线程安全,相反叫做不安全。
++/–(非原子性)
1,读取
2,运算
3,保存

线程不安全的原因

1、cpu抢占执行(万恶之源)
2、 非原子性
3、编译器优化(代码优化)
编译器优化在单线程下可以提升程序的执行效率,但是在多线程下就会出现混乱,导致不安全的问题。指令重排序 volatile
4.内存可见性问题 volatile
5、多个线程修改了同一个变量

解决线程不安全的方法

1、volatile 轻量级解决 线程安全 的方案
作用:禁止指令重排序 解决线程可见性问题
实现原理:当操作完变量之后,强制删除线程工作内存中的变量
volatile不能解决原子性问题

线程的工作方式:
先在自己的工作内存中找变量,再在主内存中找。

所以只能从其他方面解决线程安全:
分析:

cpu抢占式调度(不能)
每个线程操作自己的变量 不通用,修改难度大
在关键代码上让所有的cpu排队执行,加锁

2、加锁
锁操作的关键步骤
尝试获取(如果成功,拿到锁就可以加锁了,如果拿不到,排队)
释放锁

Java中解决线程安全问题的方案只有两个
1、//加锁 lock.lock(); try{ number++; }finally { //释放锁 lock.unlock(); }

原因:
1、如果将lock方法放在try里面,那么当try里面的代码出现异常之后,那么就会执行finally里面的释放锁,但是加锁没成功,会出现问题
2,、 当执行finally里面释放锁的代码就会报错 (线程状态异常),释放锁的异常会覆盖点业务代码的异常报错,从而增加了排查错误的成本

Lock 默认的锁策略也是非公平锁,但是Lock显示的声明为公平锁。

注意:Lock只能用来修饰代码块。

总结

volatile 和synchronized有什么区别
volatile可以解决内存可见性问题和禁止指令重排序 但volatile不能解决原子性问题
synchronized 是用来保证线程安全的 ,他可以解决任何关于线程安全的问题(保证了关键代码排序执行,始终只有一个线程会执行加锁操作, 解决原子性问题 内存可见性问题 指令重排序问题)

synchronized 和 lock的区别
1、他们修饰的场景不一样
synchronized既可以修饰代码块,又可以修饰静态代码块或者普通方法 而lock只能修饰代码块
synchronized只有非公平锁机制 lock既可以是公平锁也可以是非 公平锁(Reentrantlock默认是非公平锁,但是可以设置构造函数设置true声明他为公平锁)
使用ReentrantLock更加的灵活
synchronized是自动加锁释放锁的,lock是程序员手动加锁释放锁

版权声明:玥玥 发表于 2021-05-13 17:56:59。
转载请注明:多线程之属性、中断、状态、安全 | 女黑客导航