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

查看线程的一些属性

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、synchronized 加速和释放锁 （JVM层面的解决方案） 排队的意思
2、Lock 手动锁（程序员自己加锁和释放锁）

2.1 synchronized
synchronized 注意事项：在进行加锁操作的时候，同一组业务一定是同一个锁对象。
synchronized 实现原理：
1，操作系统：互斥锁 mutex
2，JVM：帮我们是实现了监视器锁的加锁和释放锁的操作
3，Java：
锁对象 mutex
锁存放的地方：变量的对象头

当线程释放锁时，JMM会把该线程对应的工作内存中的共享变量刷新到主内存中；
当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的临界区代码；

注意：synchronized JDK 1.6 之前使用重量级锁实现的，性能非常低。
JDK1.6对其做了一个优化（锁升级）无锁->偏向锁->轻量级锁->重量级锁
无锁：没有人访问
偏向锁：第一个线程第一次访问
轻量级锁：while(true) {//尝试获取锁} 自旋
重量级锁：停止自旋，并且把当前没有获取到锁的线程放到等待队列里

synchronized锁机制是非公平锁。
公平锁可以按序执行，而非公平锁执行的效率更高。
在Java中所有锁默认的策略都是非公平锁。

synchronized 的使用场景
1、使用synchronized 来修饰代码块 加锁对象可以自定义
2、使用synchronized 来修饰静态方法 加锁对象是当前的类对象
3、使用synchronized 来修饰普通方法 加锁对象是当前对象的实例

2.2 Lock
注意事项：一定要把lock（）放在try外面

//加锁
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是程序员手动加锁释放锁