异步编程

线程的5个状态

新建状态（New）
- 当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread();
就绪状态（Runnable）
- 当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，获取cpu的使用权,并不是说执行了t.start()此线程立即就会执行
运行状态（Running）
- 就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中
- 线程获得了cpu 时间片,执行程序代码,只有此状态才能获取cpu时间片
阻塞状态（Blocked）
- 等待阻塞:运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；，JVM会把该线程放入等待队列(waitting queue)中。
- 同步阻塞:运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，获取synchronized同步锁失败 , 它会进入同步阻塞状态 ,则JVM会把该线程放入锁池(lock pool)中。
- 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。
死亡状态（Dead）
- 线程执行完了或者因异常退出了run()方法，该线程结束生命周期,死亡的线程不可再次复生。

Synchronized

先来看一个很诡异的问题,子线程更改flag,主线程却永远也不会打印true,这是因为jmm(JavaMemoryModel)的原因
JMM 有以下规定:
- 所有的共享变量都存储于主内存，这里所说的变量指的是实例变量和类变量，不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。
- 每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。
- 线程对变量的所有的操作(读，取)都必须在工作内存中完成，而不能直接读写主内存中的变量
- 不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存中转来完成。
- JMM对底层尽量减少约束，使其能够发挥自身优势。因此，在执行程序时，为了提高性能，编译器和处理器常常会对指令进行重排序
  - 编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序;
  - 指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序;
  - 内存系统的重排序。由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行的。
  - 编译器、runtime和处理器都必须遵守as-if-serial语义,即不管怎么重排序，单线程下的执行结果不能被改变。

public class JmmTest {
    public static void main(String[] args) throws Exception {
        myclass mycls = new myclass();
        mycls.start();
        while (true) {
            // 下面这一行打印打开,或者任意开辟一块内存,都可以正确执行,这里的执行逻辑还没弄懂
            // System.out.println("anything");
            if (mycls.isFlag()) {
                System.out.println("true");
                break;
            }
            Thread.sleep(1000);
        }

    }

    public static class myclass extends Thread {

        private boolean flag = false;

        public boolean isFlag() {
            return flag;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
        }
    }

}

解决方案也很简单,对资源加锁即可.可以使用对flag字段使用volatile,也可以对线程对象使用synchronized,代码如下
为啥加锁可以解决可见性问题呢?
- 因为某一个线程进入synchronized代码块前后，线程会获得锁，清空工作内存，从主内存拷贝共享变量最新的值到工作内存成为副本，执行代码，将修改后的副本的值刷新回主内存中，线程释放锁。而获取不到锁的线程会阻塞等待，所以变量的值肯定一直都是最新的。
Volatile做了啥?
- volatile保证不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，当修改写回主内存时，另外一个线程立即看到最新的值。

public class JmmTest {
    public static void main(String[] args) throws Exception {
        myClass myCls = new myClass();
        myCls.start();
        while (true){
            boolean a= myCls.isFlag();
            // 方法一
            synchronized (myCls){
                if (a) {
                    System.out.println("true");
                    break;
                }}
        }

    }

    public static class myClass extends Thread {

        private boolean flag = false;
//        方法二
//        private volatile boolean flag = false; 

        public boolean isFlag() {
            return flag;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
        }
    }

}

volatile与synchronized的区别

volatile只能修饰实例变量和类变量，而synchronized可以修饰方法，以及代码块
volatile保证数据的可见性，但是不保证原子性(多线程进行写操作，不保证线程安全);而synchronized是一种排他(互斥)的机制。
volatile用于禁止指令重排序(volatile写操作是在前面和后面分别插入内存屏障,volatile读操作是在后面插入两个内存屏障),可以解决单例双重检查对象初始化代码执行乱序问题。
volatile可以看做是轻量版的synchronized，volatile不保证原子性，但是如果是对一个共享变量进行多个线程的赋值，而没有其他的操作(例如i++就不行)，那么就可以用volatile来代替synchronized，因为赋值本身是有原子性的，而volatile又保证了可见性，所以就可以保证线程安全了。

sleep()

当前线程释放cpu资源,但是不会释放锁资源
Thread提供的方法
sleep(0) 和不写是有区别的,在windows下cpu是抢占式的,哪个线程抢到就执行(当然优先级最高的最容易抢到),所以当一个线程长时间占用cpu时,其他线程无法抢到,这时可以短暂释放,重新让所有线程去抢.

wait()：

必须在Synchronized语句块内使用
使当前线程暂停执行并释放对象锁标志，让其他线程可以进入Synchronized数据块，当前线程被放入对象等待池中
当前线程释放CPU资源和锁资源,和notify不同,wait是立即释放锁资源
java.lang.Object提供的方法

notify()/notifyAll()

必须在Synchronized语句块内使用,锁对象必须是同一个
当调用 notify()方法后，将从对象的等待池中移走一个任意(HotSpot虚拟机不是随机一个,是按顺序先后唤醒)的线程并放到锁标志等待池中，只有锁标志等待池中的线程能够获取锁标志；如果锁标志等待池中没有线程，则notify()不起作用。
注意: 当执行完notify()方法后,并不是立即释放锁资源,而是需要继续执行到Synchronized语句块外(把Synchronized包括的所有代码执行完成后,退出Synchronized的}后)才会释放锁,这是hotspot的默认synchronized锁的释放时机,可以改为在notify之后立马唤醒相关线程

import java.util.concurrent.TimeUnit;

public class NotifyTest {
    public static void main(String[] args){
        Object lock = new Object();

        new Thread(() -> {
            System.out.println("第1个线程等待获取锁");
            synchronized (lock) {
                System.out.println("第1个线程wait");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("第1个线程wait之后再次执行");
            }
            System.out.println("第1个线程退出synchronized块");
        }).start();


        new Thread(() -> {
            System.out.println("第2个线程等待获取锁");
            synchronized (lock) {
                System.out.println("第2个线程notify");
                lock.notify();
                System.out.println("第2个线程notify后等待5s");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("第2个线程等待5s结束");
            }
            System.out.println("第2个线程退出synchronized块");
        }).start();
    }
}

执行结果:
第1个线程等待获取锁
第1个线程wait
第2个线程等待获取锁
第2个线程notify
第2个线程notify后等待5s <---------等待5s是为了更容易看到执行过程
第2个线程等待5s结束
第2个线程退出synchronized块  <---------只有退出synchronized块后才释放锁
第1个线程wait之后再次执行
第1个线程退出synchronized块

join()

Thread提供的方法,当前运行线程等待其他线程运行结束,例如在主线程中调用thread1.join()代表主线程等待thread1线程执行完毕后,主线程再继续向下执行

每个对象new完以后,都关联了一个监视器，也关联了一个等待集合。等待集合是一个线程集合,当对象被创建出来时，它的等待集合是空的，对于向等待集合中添加或者移除线程的操作都是原子的.以下几个操作可以操纵这个等待集合：Object.wait, Object.notify, Object.notifyAll。
wait()，notify()及notifyAll()只能在synchronized语句中使用，但是如果使用的是ReentrantLock实现同步，该如何达到这三个方法的效果呢？

解决方法是使用ReentrantLock.newCondition()获取一个Condition类对象，然后Condition的await()，signal()以及signalAll()分别对应上面的三个方法。

等待集合也可能受到线程的中断状态的影响，也受到线程中处理中断的方法的影响。另外，sleep 方法和 join 方法可以感知到线程的 wait 和 notify。

ReentrantLock/Condition

可重入锁,可以多次获取不同条件的锁,注意,释放锁必须在finally块中
如果要使用超时控制,可以使用reentrantLock.tryLock(long timeout, TimeUnit unit)

public class notify2 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            System.out.println("第一个线程等待获取锁");
            lock.lock();
            System.out.println("第一个线程await");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            System.out.println("第一个线程结束");
            System.out.println("第一个线程退出lock块");
        }).start();


        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("第2个线程等待获取锁");
                lock.lock();
                System.out.println("第2个线程notify");
                condition.signal();
                System.out.println("第2个线程结束");
                lock.unlock();
                System.out.println("第2个线程退出lock块");
            }
        }).start();
    }
}

yield()

yield()方法和sleep()方法类似，也不会释放“锁标志”，区别在于，它没有参数，即yield()方法只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，另外yield()方法只能使同优先级或者高优先级的线程得到执行机会，这也和sleep()方法不同。

interrupt()

interrupt方法不一定会真正”中断”线程，它只是一种协作机制,真正关闭线程需要我们自己封装. 比如说,System.in.read()从标准输入读入一个字符，不要输入任何字符，我们会看到，调用interrupt()不会中断read()，线程会一直运行

类锁和对象锁

类锁是加载类上的，而类信息是存在 JVM 方法区的，并且整个 JVM 只有一份，方法区又是所有线程共享的，所以类锁是所有线程共享的。
类声明后，我们可以 new 出来很多的实例对象。这时候，每个实例在 JVM 中都有自己的引用地址和堆内存空间，这时候，我们就认为这些实例都是独立的个体，很显然，在实例上加的锁和其他的实例就没有关系，互不影响了

类中的静态变量,静态方法,类的.class属性等加锁,都是类锁
类中的非静态变量,实例方法,this等加锁,都是实例锁

ThreadLocal

创建线程局部变量,创建的变量只能由此线程访问
常用来封装传递参数,避免在方法中来回传递参数
操作不当会导致内存泄露,ThreadLocal实例被线程的ThreadLocalMap实例持有，也可以看成被线程持有,ThreadLocalMap的每个Entry都是一个对键的弱引用,每个Entry都包含了一个对值的强引用.如果应用使用了线程池，那么之前的线程实例处理完之后出于复用的目的依然存活,所以要记得在finally里添加threadLocal.remove();

public class JmmTest {
    public static void main(String[] args) throws InterruptedException {
        myThread myCls = new myThread();
        myThread myCls2 = new myThread();
        myCls.start();
        myCls2.start();
        myCls.join();
        myCls2.join();
    }
}


class myThread extends Thread {
    private final static ThreadLocal<Double> threadLocal = new ThreadLocal<>();

    @Override
    public void run() {
        threadLocal.set(Math.random());
        try {
            Thread.sleep(1000);
            System.out.println(threadLocal.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            threadLocal.remove();
        }


    }
}

posted @ 2020-12-10 15:06 rm-rf* 阅读(111) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

异步编程

线程的5个状态

Synchronized

volatile与synchronized的区别

sleep()

wait()：

notify()/notifyAll()

join()

ReentrantLock/Condition

yield()

interrupt()

类锁和对象锁

ThreadLocal

公告