并发基础2（线程方法、synchronize关键字、voliate、lock）
目录
0：线程的状态
1:多线程的方法
1.1：Join()方法
1.2：Sleep()方法、wait()、yield()方法同属于Thread方法，不会释放锁
1.3：interrupt() 中断方法
1.4： wait() 、notifyAll（）、 notify()方法（使用在锁方法内部）
2：synchronize关键字
2.1：说一下对synchronize关键字的理解
2.2：synchronize在用项目中用到了吗？
2.2.1：synchronize用法
2.2.2：项目中的使用（懒汉单例模式）
3：说说synchronize关键字和voliate关键字
4：lock接口
4.1：为什么需要Lock接口？
4.2：代码实现
5：ThreadLocal
0：线程的状态
线程的状态有5种：
1：新建（New）：使用new关键字创建尚未启动的线程。new Thread()；就是新建一个线程
2：运行(Ruanable)：Runable包含线程的运行和就绪两种状态，也就是此时的线程正在运行或者在等待cpu为其分配执行时间
3：无限等待（Waiting）：这个时候的线程不会被CPU分配执行时间，他们要等待被其他线程显示的唤醒。一下方法会导致线程无限等待
没有设置Timeout参数的Object.wait()方法
没有设置Timeout参数的Thread.join()方法
LockSuport.park()方法
4：超时等待（Timed Wating）:这种状态不会被cpu分配执行时间。不过无需等待被其他线程唤醒，在一定时间之后会被系统自动唤醒。以下方法会进入超市等待。
Thread.sleep()
设置Timeout参数的Object.wait()方法
设置Timeout参数的Thread.join()方法
5：阻塞（Blocked）：阻塞的与等待的意思是阻塞是在等待获取一个排他锁，这个事件将在其他的线程使用这个锁的时候发生
1:多线程的方法
1.1：Join()方法
定义：当前线程加入父线程，父线程挂起，直到当前线程执行结束后才能执行父线程。
案例：
public static void main(String[] args) throws InterruptedException {
Thread thread=new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 5; i++) {
System.out.println("子线程名字："+Thread.currentThread().getName());
}
}
});
thread.start();
thread.join();
System.out.println("父线程名字："+Thread.currentThread().getName());
}输出结果分析：当前子线程执行结束才能执行父线程
1.2：Sleep()方法、wait()、yield()方法同属于Thread方法，不会释放锁
sleep定义：不会释放锁，指定当前线程睡眠时间，在睡眠时间内依然保留锁，不会释放锁，cpu会监事当前线程的睡眠时间，时间到了之后CPU会立刻执行当前线程。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据
yield定义：不是释放锁，线程让步，自己的线程有运行状态变成就绪状态，自己和其他的线程一起竞争，线程优先级高的先执行，但是不绝对，只是大概率让线程优先级高的执行，包括自己的线程。
wait定义：wait会释放锁，线程处于等待状态，不能主动再次执行，需要别的线程调用同对象的notifyAll或者notify方法唤醒才能执行。属于object方法，在synchronize块中使用
sleep案例：
public static void main(String[] args) throws InterruptedException {
long start=System.currentTimeMillis();
Thread thread=new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i < 5; i++) {
System.out.println("子线程名字："+Thread.currentThread().getName());
}
try {//线程挂起1000毫秒
Thread.currentThread().sleep(1000);;
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
},"自定义名字");
//thread.notify();
thread.start();
Thread.currentThread().sleep(1000);
thread.join();
System.out.println("父线程名字："+Thread.currentThread().getName());
System.out.println("耗时："+(System.currentTimeMillis()-start));
}yield案例
package com.thit.thread1;
public class YieldTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread a=new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i <10; i++) {
System.out.println("a线程优先级低："+i);
//每次出让线程，但是a由于优先级低 大概率抢不到下次执行
Thread.yield();
}
}
});
Thread b=new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
for (int i = 0; i <10; i++) {
System.out.println("b线程优先级高："+i);
Thread.yield();//出让当前资源，由于线程优先级高，大概率会下次执行
}
}
});
a.setPriority(Thread.MIN_PRIORITY);//a线程优先级低
b.setPriority(Thread.MAX_PRIORITY);//b线程优先级高
b.start();
a.start();
}
}
执行结果不是每次都能按照预测的结果，因为线程释放之后重新开始运行随机性很大，并且线程优先级映射到windows内核也很不确定。
1.3：interrupt() 中断方法
定义：该方法只是改变中断状态而已，它不会中断一个正在运行的线程。
这一方法实际完成的是，给受阻塞的线程发出一个中断信号，这样受阻线程就得以退出阻塞的状态。唤醒正在睡眠的程序，调用interrupt()方法，会使得sleep()方法抛出InterruptedException异常，当sleep()方法抛出异常就中断了sleep的方法，从而让程序继续运行下去
结果如下：
1.4： wait() 、notifyAll（）、 notify()方法（使用在锁方法内部）
wait、notify和notifyAll方法是Object类的final native方法。所以这些方法不能被子类重写，Object类是所有类的超类，因此在程序中可以通过this或者super来调用this.wait(), super.wait()
wait方法定义：会释放锁，导致线程进入阻塞状态，会等待被其他线程使用notify方法唤醒，该方法只能在同步方法中执行，
notify方法定义：只能使用在同步方法和同步代码中，此方法只能随机选择一个在该对象的上调用wait方法的线程
notifyAll方法定义: 唤醒所有的wait对象
注意
1：Object.wait()和Object.notify()和Object.notifyall()必须写在synchronized方法内部或者synchronized块内部:
2：注意那个对象等待就通知那个对象使用notify方法，不要让A对象等待，结果却去通知B对象，要操作同一个对象
public static void main(String[] args) throws InterruptedException {
// TODO Auto-generated method stub
//两个线程竞争同一对象的加锁方法，
//线程1进入该方法然后等待，无限时间挂起，线程2依旧
//线程3通过唤醒了该对象的所有挂起线程方法
WaitTest1 test1 = new WaitTest1();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
test1.waitFile();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
test1.waitFile();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
t2.start();
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
try {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t睡觉1秒中，目的是让上面的线程先执行，即先执行wait()");
Thread.sleep(2000);
test1.notifyFile();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
t3.start();
t1.join();
t2.join();
t3.join();
System.out.println("结束");
}
//wait必须使用在加锁的方法中
//因为不加锁，不存在多线程竞争，就不能使用等待方法
synchronized void waitFile() throws InterruptedException {
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t等待打印文件...");
wait();
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t打印结束。。。");
}
synchronized void notifyFile() {
//notify();//只能唤醒该对象的随机一个方法,程序不会结束
this.notifyAll();//这是程序才能执行完毕
System.out.println(new Date() + "\t" + Thread.currentThread().getName() + "\t通知完成...");
}
2：synchronize关键字
2.1：说一下对synchronize关键字的理解
synchronize关键字解决了多线程的资源同步性，该关键字保证了在多线程的条件下，同时是有一个线程能够获取到资源。
在jdk的早起版本中，这个关键字是重量级锁，这个关键字在编译之后，在同步块的前后会形成monitorenter和monitorexit（监视器进入和退出，通过获取对象锁计数器加一减一来实现锁机制）两个节码指令，其他线程在竞争的时候会挂起，效率低下，但是随着jdk的发展，通过对synchronize底层的发展，不必每次线程都挂起。来大大提升了效率
比如采用偏向锁、轻量级锁、锁粗化、锁自旋、锁自旋、锁消除等手段来提升效率。
2.2：synchronize在用项目中用到了吗？
2.2.1：synchronize用法
1：用来修饰静态方法（给类加了锁，无论new多少个对象，都会产生竞争，线程1new的对象获取普通加锁方法和线程2获取类的静态加锁方法不会产生竞争）
2：用来修饰静态代码块（也是给类加了锁）
3：用来修饰普通方法（锁给了对象，只用new的同一对象才有竞争）
2.2.2：项目中的使用（懒汉单例模式）
代码块如下:双重锁效验线程安全
package com.thit.connpool;
public class LazySimple {
//voliate修饰，禁止指令重排
private static volatile LazySimple lazySimple;
//私有构造防止new创建对象
private LazySimple() {
}
//静态方法外部得到实例
public static LazySimple getDanli() {
//首先判断是否为空
if (lazySimple==null) {
synchronized (LazySimple.class) {
//再次判断是否为空
if(lazySimple==null) {
//new 对象非原子性操作
//1：分配内存空间
//2：初始化值(构造器)
//3：将对象指向内存地址
lazySimple=new LazySimple();
}
}
}
return lazySimple;
}
}
代码分析：
1：其中 volatile修饰lazySimple;是为了防止指令重排,其中lazySimple=new LazySimple();这段代码不是原子性操作，实际分为3步
//1：分配内存空间
//2：初始化值
//3：将引用指向内存地址
lazySimple=new LazySimple();
由于jvm有指令重排的优化，所以代码执行顺序可能是1>3>2，当线程1执行1>3的时候没有执行到2初始化赋值的时候，线程2进入执行，这个时候判断到lazySimple==null,会在创造一个对象，就不是单例了。加了voliate关键字修饰，会因为可见性而防止指令重排，因为其他的线程想要判断lazySimple==null的时候，会在1>2>3执行完成，在线程1修改lazySimple的时候，没写入之前内存像是有屏障一般。这边形成了指令重排无法越过的内存屏障。
3：说说synchronize关键字和voliate关键字
1：voliate修饰变量多线程可见性但是没有原子性，synchronize修饰方法能保证可见性和原子性。
2：voliate的效率更高一点，线程不会阻塞，但是synchronize线程会阻塞
3：voliate用来解决变量的多线程可见性，但是synchronize用来解决多线程资源访问问题
4：lock接口
4.1：为什么需要Lock接口？
我们知道锁是来控制多线程并发访问资源的竞争，在Lock接口出现之前我们使用synchronize关键字来实现锁功能，但是synchronize获取锁是隐式的，我们无法控制锁的获取，释放中断的可操作性性，由于synchronize获取锁固话，所以创建了Lock接口来实现更领过的锁。
Lock和synchronize都是重入锁
1：尝试非中断的获取锁，
2：可以实现中断，与synchronize关键字不同，当获取锁的线程能够响应中断，中断的时候，异常内抛出，释放锁
3：能指定时间获取锁，在指定时间内无法获取锁的时候返回
4.2：代码实现
Lock lock=new ReentrantLock();
lock.lock();//获取锁
try {
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();//finally修饰，异常处理，一定要释放锁
}5：ThreadLocal
多线程的情况下，变量一般都存在一致性问题，有没有线程的专属变量？如果想实现每一个线程都有自己的专属本地变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。
代码示例如下：
package com.thit.thread1;
public class ThreadLocalTest1 implements Runnable{
private static ThreadLocal strings=new ThreadLocal<>();
public static void main(String[] args) {
// TODO Auto-generated method stub
ThreadLocalTest1 t=new ThreadLocalTest1();
Thread t1=new Thread(t);
t1.start();
System.out.println("main线程获取值:"+strings.get());
Thread t2=new Thread(new Runnable() {
@Override
public void run() {
strings.set("线程22222");
System.out.println("线程2执行得到ThreadLocal："+strings.get());
}
});
t2.start();
}
@Override
public void run() {
// TODO Auto-generated method stub
strings.set("hell oword");
System.out.println("线程1执行得到ThreadLocal："+strings.get());
}
}
输出结果如下：不同的线程set，会得到不同的值
