mysql 异步编程_异步编程

线程的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资源和锁资源

java.lang.Object提供的方法

notify()/notifyAll()

必须在Synchronized语句块内使用,锁对象必须是同一个

当调用 notify()方法后，将从对象的等待池中移走一个任意(HotSpot虚拟机不是随机一个,是按顺序先后唤醒)的线程并放到锁标志等待池中，只有锁标志等待池中的线程能够获取锁标志；如果锁标志等待池中没有线程，则notify()不起作用。

注意: 当执行完notify()方法后,并不是立即释放锁资源,而是需要继续执行到Synchronized语句块外才会释放锁

public class NotifyTest {

public static void main(String[] args){

Object lock = new Object();

new Thread(() -> {

System.out.println("第一个线程等待获取锁");

synchronized (lock) {

System.out.println("第一个线程wait");

try {

lock.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("第一个线程结束");

}

System.out.println("第一个线程退出synchronized块");

}).start();

new Thread(new Runnable() {

@Override

public void run() {

System.out.println("第2个线程等待获取锁");

synchronized (lock) {

System.out.println("第2个线程notify");

lock.notify();

System.out.println("第2个线程结束");

}

System.out.println("第2个线程退出synchronized块");

}

}).start();

}

}

执行结果:

第一个线程等待获取锁

第一个线程wait

第2个线程等待获取锁

第2个线程notify

第2个线程结束

第2个线程退出synchronized块

第一个线程结束

第一个线程退出synchronized块

join()

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

wait()，notify()及notifyAll()只能在synchronized语句中使用，但是如果使用的是ReentrantLock实现同步，该如何达到这三个方法的效果呢？

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

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()，线程会一直运行

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 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();

}

}

}