多线程(2)

Thread类及常见方法

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有一个唯一的 Thread 对象与之关
联

常见构造方法

1. Thread() 创建线程对象
2. Thread(Runnable target) 使用 Runnable 对象创建线程对象
3. Thread(String name) 创建线程对象，并命名
4. Thread(Runnable target, String name) 使用 Runnable 对象创建线程对象，并命名

常见属性

ID：获取方法为getld() 是线程的唯一标识，不同线程不会重复，具有唯一性
名称：获取方法为getname() 功能是当作各种调试工具
状态：获取方法为getState() 状态表示线程当前所处的一个情况
优先级：获取方法为getPriority() 优先级高的线程理论上更容易被调度
是否为后台线程：获取方法为isDaemon 最主要的是：JVM会在一个线程的所有非后台线程结束后，才会结束运行
是否存活：获取方法为isAlive() 相当于run方法是否结束
是否被中断：获取方法为isinterrupted()
代码：

public class demo001 { {
            Thread t = new Thread(()->{
                for (int i = 0;i < 5;i ++) {
                    System.out.println("线程~");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            },"newThread");
            System.out.println("线程状态：" +t.getState());
            //创建对象
            t.start();
            System.out.println("线程状态：" +t.getState());
            //创建线程
            System.out.println("线程Id："+t.getId());
            System.out.println("线程名称："+t.getName());
            System.out.println("线程是否为后台线程：" + t.isDaemon());
            System.out.println("线程是否被中断：" + t.isInterrupted());
            System.out.println("线程优先级为：" + t.getPriority());
            System.out.println("主线程名称："+Thread.currentThread().getName());
            while (t.isAlive()) {} 
            System.out.println("线程状态：" +t.getState());
            //线程结束
        }
    }

结果:

中断线程

方法总共两种:

1. 通过共享的标记来进行沟通
2. 调用 interrupt() 方法来通知

方法一

使用自定义的变量作为标志位,通过volatile关键字

import java.util.concurrent.TimeUnit;

public class Main {
        private static volatile boolean isStop=false;
        private static void m1_volatile() throws InterruptedException {
            new Thread(()->{
                while (true){
                    if (isStop){
                        System.out.println(Thread.currentThread().getName()+"\t isStop被修改为true，程序停止");
                        break;
                    }
                    System.out.println(Thread.currentThread().getName()+"\t 程序运行中");
                }
            },"A").start();

            //暂停一会
            TimeUnit.MILLISECONDS.sleep(1);

            new Thread(()->{
                isStop=true;//向A线程发送一个请求暂停的信号
            },"B").start();
        }
    }

方法二

通过AtomicBoolean类

    private static AtomicBoolean atomicBoolean=new AtomicBoolean(false);
    private static void m2_atomicBoolean() throws InterruptedException {
        new Thread(()->{
            while (true){
                if (atomicBoolean.get()){
                    System.out.println(Thread.currentThread().getName()+"\t atomicBoolean被修改为true，程序停止");
                    break;
                }
                System.out.println(Thread.currentThread().getName()+"\t 程序运行中");
            }
        },"A").start();
 
        //暂停一会
        TimeUnit.MILLISECONDS.sleep(5);
 
        new Thread(()->{
            atomicBoolean.set(true);//向A线程发送一个请求暂停的信号
        },"B").start();
    }

方法三

.通过Thread类自带的中断API实例方法实现

    private static void m3_isInterrupted() throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("t1的默认标中断志位："+Thread.currentThread().isInterrupted());//false
                    System.out.println(Thread.currentThread().getName() + "\t isInterrupted()被修改为true，程序停止");
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "\t 程序运行中");
            }
        }, "A");
        t1.start();
 
        System.out.println("t1的默认标中断志位："+t1.isInterrupted());//false
        //暂停一会
        TimeUnit.MILLISECONDS.sleep(5);
 
//        new Thread(()->{
//            t1.interrupt();//向A线程发送一个请求暂停的信号
//        },"B").start();
 
        //也可以自己设置
        t1.interrupt();
    }

当前进程休眠

方法:public static void sleep(long millis) throws InterruptedException
作用:休眠当前线程 millis毫秒
public static void sleep(long millis, int nanos) throwsInterruptedException
作用:可以更高精度的休眠

  public static void main(String[] args) throws InterruptedException {
        System.out.println(System.currentTimeMillis());
        Thread.sleep(3 * 1000);
        System.out.println(System.currentTimeMillis());
   }

线程安全

概念:如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线
程安全的。

不安全的原因

1.修改共享数据
2.原子性:将代码比作一个没有锁的房间,进程比作想要进去的人,当A进入时,B是不是也可以进去打断A?C是不是也可以?这就是没有原子性,也可以想作没有隐私的人.是不是只要给房间加一把锁，A 进去就把门锁上，其他人是不是就进不来了。这样就保证了这段代码的原子性了。有时也把这个现象叫做同步互斥，表示操作是互相排斥的
3.可见性 指 一个线程对共享变量值的修改，能够及时地被其他线程看到