目录
一、什么是JUC
1、JUC概述
2、进程与线程
3、线程的状态
4、wait/sleep 的区别
5、并发与并行
6、管程
7、用户线程和守护线程
二、Lock接口
1、Synchronized
使用synchronized实现售票案例
使用synchronized实现增减变量操作
2、什么是 Lock
买票例子使用lock实现
增减变量操作使用lock实现
3、newCondition
增减变量操作使用Condition实现
线程定制化执行
4、ReentrantLock
5、ReadWriteLock
一、什么是JUC
1、JUC概述
JUC 就是 java.util .concurrent 工具包的简称。这是一个处理线程的工具包,JDK 1.5 开始出现的。
2、进程与线程
3、线程的状态
public enum State {/*** Thread state for a thread which has not yet started.*/NEW, // 新建/*** Thread state for a runnable thread. A thread in the runnable* state is executing in the Java virtual machine but it may* be waiting for other resources from the operating system* such as processor.*/RUNNABLE, // 运行时/*** Thread state for a thread blocked waiting for a monitor lock.* A thread in the blocked state is waiting for a monitor lock* to enter a synchronized block/method or* reenter a synchronized block/method after calling* {@link Object#wait() Object.wait}.*/BLOCKED, // 阻塞/*** Thread state for a waiting thread.* A thread is in the waiting state due to calling one of the* following methods:* <ul>* <li>{@link Object#wait() Object.wait} with no timeout</li>* <li>{@link #join() Thread.join} with no timeout</li>* <li>{@link LockSupport#park() LockSupport.park}</li>* </ul>** <p>A thread in the waiting state is waiting for another thread to* perform a particular action.** For example, a thread that has called <tt>Object.wait()</tt>* on an object is waiting for another thread to call* <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on* that object. A thread that has called <tt>Thread.join()</tt>* is waiting for a specified thread to terminate.*/WAITING, //等待/*** Thread state for a waiting thread with a specified waiting time.* A thread is in the timed waiting state due to calling one of* the following methods with a specified positive waiting time:* <ul>* <li>{@link #sleep Thread.sleep}</li>* <li>{@link Object#wait(long) Object.wait} with timeout</li>* <li>{@link #join(long) Thread.join} with timeout</li>* <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>* <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>* </ul>*/TIMED_WAITING, // 过时不候/*** Thread state for a terminated thread.* The thread has completed execution.*/TERMINATED; //终结}
4、wait/sleep 的区别
5、并发与并行
并发:并发是指两个或多个事件在同一时间间隔发生。
- 例子:春运抢票 电商秒杀...
并行:并行是指两个或者多个事件在同一时刻发生。
- 例子:泡方便面,电水壶烧水,一边撕调料倒入桶中
6、管程
7、用户线程和守护线程
二、Lock接口
1、Synchronized
- 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象;
- 修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
- 修改一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象;
- 修改一个类,其作用的范围是 synchronized 后面括号括起来的部分,作用主的对象是这个类的所有对象
虽然可以使用 synchronized 来定义方法,但 synchronized 并不属于方法定义的一部分,因此,synchronized 关键字不能被继承。如果在父类中的某个方法使用了 synchronized 关键字,而在子类中覆盖了这个方法,在子类中的这个方法默认情况下并不是同步的,而必须显式地在子类的这个方法中加上synchronized 关键字才可以。当然,还可以在子类方法中调用父类中相应的方法,这样虽然子类中的方法不是同步的,但子类调用了父类的同步方法,因此,子类的方法也就相当于同步了。
使用synchronized实现售票案例
//第一步 创建资源类,定义属性和和操作方法
class Ticket {//票数private int number = 30;//操作方法:卖票public synchronized void sale() {//判断:是否有票if(number > 0) {System.out.println(Thread.currentThread().getName()+" : 卖出:"+(number--)+" 剩下:"+number);}}
}public class SaleTicket {//第二步 创建多个线程,调用资源类的操作方法public static void main(String[] args) {//创建Ticket对象Ticket ticket = new Ticket();//创建三个线程new Thread(new Runnable() {@Overridepublic void run() {//调用卖票方法for (int i = 0; i < 40; i++) {ticket.sale();}}},"AA").start();new Thread(new Runnable() {@Overridepublic void run() {for(int i = 0; i < 40; i ++) {ticket.sale();}}},"DD");new Thread(new Runnable() {@Overridepublic void run() {//调用卖票方法for (int i = 0; i < 40; i++) {ticket.sale();}}},"BB").start();new Thread(new Runnable() {@Overridepublic void run() {//调用卖票方法for (int i = 0; i < 40; i++) {ticket.sale();}}},"CC").start();}
}
使用synchronized实现增减变量操作
当变量为0是线程A、C将其+1,当变量为1时B、D线程将其-1
//第一步 创建资源类,定义属性和操作方法
class Share {//初始值private int number = 0;//+1的方法public synchronized void incr() throws InterruptedException {//第二步 判断 干活 通知while(number != 0) { //判断number值是否是0,如果不是0,等待this.wait(); //在哪里睡,就在哪里醒}//如果number值是0,就+1操作number++;System.out.println(Thread.currentThread().getName()+" :: "+number);//通知其他线程this.notifyAll();}//-1的方法public synchronized void decr() throws InterruptedException {//判断while(number != 1) {this.wait();}//干活number--;System.out.println(Thread.currentThread().getName()+" :: "+number);//通知其他线程this.notifyAll();}
}public class ThreadDemo1 {//第三步 创建多个线程,调用资源类的操作方法public static void main(String[] args) {Share share = new Share();//创建线程new Thread(()->{for (int i = 1; i <=10; i++) {try {share.incr(); //+1} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.decr(); //-1} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.incr(); //+1} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.decr(); //-1} catch (InterruptedException e) {e.printStackTrace();}}},"DD").start();}
}
如果一个代码块被 synchronized 修饰了,当一个线程获取了对应的锁,并执行该代码块时,其他线程便只能一直等待,等待获取锁的线程释放锁,而这里获取锁的线程释放锁只会有两种情况:
2、什么是 Lock
- Lock 不是 Java 语言内置的,synchronized 是 Java 语言的关键字,因此是内置特性。Lock 是一个类,通过这个类可以实现同步访问;
- Lock 和 synchronized 有一点非常大的不同,采用 synchronized 不需要用户去手动释放锁,当 synchronized 方法或者 synchronized 代码块执行完之后,系统会自动让线程释放对锁的占用;而 Lock 则必须要用户去手动释放锁,如果没有主动释放锁,就有可能导致出现死锁现象。
public interface Lock {void lock();void lockInterruptibly() throws InterruptedException;boolean tryLock();boolean tryLock(long time, TimeUnit unit) throws InterruptedException;void unlock();Condition newCondition();
}
lock.lock();try{//处理任务}catch(Exception ex){}finally{lock.unlock(); //释放锁}
买票例子使用lock实现
//第一步 创建资源类,定义属性和和操作方法
class LTicket {//票数量private int number = 30;//创建可重入锁private final ReentrantLock lock = new ReentrantLock(true);//卖票方法public void sale() {//上锁lock.lock();try {//判断是否有票if(number > 0) {System.out.println(Thread.currentThread().getName()+" :卖出"+(number--)+" 剩余:"+number);}} finally {//解锁lock.unlock();}}
}public class LSaleTicket {//第二步 创建多个线程,调用资源类的操作方法//创建三个线程public static void main(String[] args) {LTicket ticket = new LTicket();new Thread(()-> {for (int i = 0; i < 40; i++) {ticket.sale();}},"AA").start();new Thread(() -> {for(int i = 0; i < 40; i ++) {ticket.sale();}}, "DD");new Thread(()-> {for (int i = 0; i < 40; i++) {ticket.sale();}},"BB").start();new Thread(()-> {for (int i = 0; i < 40; i++) {ticket.sale();}},"CC").start();}
}
增减变量操作使用lock实现
//第一步 创建资源类,定义属性和操作方法
class Share {private int number = 0;//创建Lockprivate Lock lock = new ReentrantLock();private Condition condition = lock.newCondition();//+1public void incr() throws InterruptedException {//上锁lock.lock();try {//判断while (number != 0) {condition.await();}//干活number++;System.out.println(Thread.currentThread().getName()+" :: "+number);//通知condition.signalAll();}finally {//解锁lock.unlock();}}//-1public void decr() throws InterruptedException {lock.lock();try {while(number != 1) {condition.await();}number--;System.out.println(Thread.currentThread().getName()+" :: "+number);condition.signalAll();}finally {lock.unlock();}}
}public class ThreadDemo2 {public static void main(String[] args) {Share share = new Share();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"DD").start();}}
3、newCondition
注意:在调用 Condition 的 await()/signal()方法前,也需要线程持有相关的 Lock 锁,调用 await()后线程会释放这个锁,在 singal()调用后会从当前 Condition 对象的等待队列中,唤醒 一个线程,唤醒的线程尝试获得锁, 一旦获得锁成功就继续执行。
增减变量操作使用Condition实现
//第一步 创建资源类,定义属性和操作方法
class Share {private int number = 0;//创建Lockprivate Lock lock = new ReentrantLock();private Condition condition = lock.newCondition();//+1public void incr() throws InterruptedException {//上锁lock.lock();try {//判断while (number != 0) {condition.await();}//干活number++;System.out.println(Thread.currentThread().getName()+" :: "+number);//通知condition.signalAll();}finally {//解锁lock.unlock();}}//-1public void decr() throws InterruptedException {lock.lock();try {while(number != 1) {condition.await();}number--;System.out.println(Thread.currentThread().getName()+" :: "+number);condition.signalAll();}finally {lock.unlock();}}
}public class ThreadDemo2 {public static void main(String[] args) {Share share = new Share();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"DD").start();}}
线程定制化执行
让线程按顺序执行,例子:
当flag为1时,A线程打印五次;
当flag为2时,B线程打印十次;
当flag为3时,C线程打印十五次;
按顺序打印。
//第一步 创建资源类
class ShareResource {//定义标志位private int flag = 1; // 1 AA 2 BB 3 CC//创建Lock锁private Lock lock = new ReentrantLock();//创建三个conditionprivate Condition c1 = lock.newCondition();private Condition c2 = lock.newCondition();private Condition c3 = lock.newCondition();//打印5次,参数第几轮public void print5(int loop) throws InterruptedException {//上锁lock.lock();try {//判断while(flag != 1) {//等待c1.await();}//干活for (int i = 1; i <=5; i++) {System.out.println(Thread.currentThread().getName()+" :: "+i+" :轮数:"+loop);}//通知flag = 2; //修改标志位 2c2.signal(); //通知BB线程}finally {//释放锁lock.unlock();}}//打印10次,参数第几轮public void print10(int loop) throws InterruptedException {lock.lock();try {while(flag != 2) {c2.await();}for (int i = 1; i <=10; i++) {System.out.println(Thread.currentThread().getName()+" :: "+i+" :轮数:"+loop);}//修改标志位flag = 3;//通知CC线程c3.signal();}finally {lock.unlock();}}//打印15次,参数第几轮public void print15(int loop) throws InterruptedException {lock.lock();try {while(flag != 3) {c3.await();}for (int i = 1; i <=15; i++) {System.out.println(Thread.currentThread().getName()+" :: "+i+" :轮数:"+loop);}//修改标志位flag = 1;//通知AA线程c1.signal();}finally {lock.unlock();}}
}public class ThreadDemo3 {public static void main(String[] args) {ShareResource shareResource = new ShareResource();new Thread(()->{for (int i = 1; i <=10; i++) {try {shareResource.print5(i);} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {shareResource.print10(i);} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(()->{for (int i = 1; i <=10; i++) {try {shareResource.print15(i);} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();}
}
4、ReentrantLock
public class Test {private ArrayList<Integer> arrayList = new ArrayList<Integer>();public static void main(String[] args) {final Test test = new Test();new Thread() {public void run() {test.insert(Thread.currentThread());};}.start();new Thread() {public void run() {test.insert(Thread.currentThread());};}.start();}public void insert(Thread thread) {ReentrantLock lock = new ReentrantLock(); //注意这个地方lock.lock();try {System.out.println(thread.getName() + "得到了锁");for (int i = 0; i < 5; i++) {arrayList.add(i);}} catch (Exception e) {
// TODO: handle exception} finally {System.out.println(thread.getName() + "释放了锁");lock.unlock();}}
}
5、ReadWriteLock
public interface ReadWriteLock {/*** Returns the lock used for reading.** @return the lock used for reading.*/Lock readLock();/*** Returns the lock used for writing.** @return the lock used for writing.*/Lock writeLock();
}
public class Test {private ReentrantReadWriteLock rwl = newReentrantReadWriteLock();public static void main(String[] args) {final Test test = new Test();new Thread() {public void run() {test.get(Thread.currentThread());};}.start();new Thread() {public void run() {test.get(Thread.currentThread());};}.start();}public synchronized void get(Thread thread) {long start = System.currentTimeMillis();while (System.currentTimeMillis() - start <= 1) {System.out.println(thread.getName() + "正在进行读操作");}System.out.println(thread.getName() + "读操作完毕");}
}
而改成用读写锁的话:
public class Test {private ReentrantReadWriteLock rwl = newReentrantReadWriteLock();public static void main(String[] args) {final Test test = new Test();new Thread() {public void run() {test.get(Thread.currentThread());};}.start();new Thread() {public void run() {test.get(Thread.currentThread());};}.start();}public void get(Thread thread) {rwl.readLock().lock();try {long start = System.currentTimeMillis();while (System.currentTimeMillis() - start <= 1) {System.out.println(thread.getName() + "正在进行读操作");}System.out.println(thread.getName() + "读操作完毕");} finally {rwl.readLock().unlock();}}
}
== 注意: ==• 如果有一个线程已经占用了读锁,则此时其他线程如果要申请写锁,则申请写锁的线程会一直等待释放读锁。• 如果有一个线程已经占用了写锁,则此时其他线程如果申请写锁或者读锁,则申请的线程会一直等待释放写锁。
Lock 和 synchronized 有以下几点不同:
- Lock 是一个接口,而 synchronized 是 Java 中的关键字,synchronized 是内置的语言实现;
- synchronized 在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象发生;而 Lock 在发生异常时,如果没有主动通过 unLock()去释放锁,则很可能造成死锁现象,因此使用 Lock 时需要在 finally 块中释放锁;
- Lock 可以让等待锁的线程响应中断,而 synchronized 却不行,使用synchronized 时,等待的线程会一直等待下去,不能够响应中断;
- 通过 Lock 可以知道有没有成功获取锁,而synchronized 却无法办到。
- Lock 可以提高多个线程进行读操作的效率。
在性能上来说,如果竞争资源不激烈,两者的性能是差不多的,而当竞争资源非常激烈时(即有大量线程同时竞争),此时 Lock 的性能要远远优于synchronized。