Java写程序三部分组成:
1、JDK系统类库
JRE: Java Runtime Environment (Java运行环境),仅供运行程序的。
JDK: Java Development Kit (Java开发工具包),如果需要进行程序开发,必须安装JDK。
string、Scanner、包装类。。。
java.lang.Thread
javax.servlet.Servlet
2、第三方类库
非Java官方的组织提供的一些成熟好用的工具,C3PO数据库连接池、Spring框架、DBUtils、Dom…
github
3、开发者自定义的代码
根据具体的业务需求编写的业务代码。
1、多线程
多线程是提升程序性能非常重要的一种方式,必须掌握的技术。
使用多线程可以让程序充分利用CPU 资源。
优点
系统资源得到更合理的利用。
程序设计更加简洁。
程序响应更快,运行效率更高。
缺点
需要更多的内存空间来支持多线程。
多线程并发访问的情况可能会影响数据的准确性。
数据被多线程共享,可能会出现死锁的情况。
进程和线程
什么是进程:
进程就是计算机正在运行的一个独立的应用程序。
进程是一个动态的概念,当我们启动某个应用的时候,进程就产生了,当我们关闭该应用的时候,进程就结束了进程的生命周期就是我们
在使用该软件的整个过程。
什么是线程?
线程是组成进程的基本单位,可以完成特定的功能,一个进程是由一个或多个线程组成的。
应用程序是静态的,进程和线程是动态的,有创建有销毁,存在是暂时的,不是永久的。
进程和线程的区别
进程在运行时拥有独立的内存空间,即每个进程所占用的内存空间都是独立的,互不干扰。
线程是共享内存空间的,但是每个线程的执行都是相互独立的,单独的线程是无法执行的,由进程来控制多个线程的执行。
多线程
多线程是指在一个进程中,多个线程同时执行,这里说的同时执行并不是真正意义的同时执行。
系统会为每个线程分配CPU 资源,在某个具体的时间段内CPU 资源会被一个线程占用,
在不同的时间段内由不同的线程来占用CPU资源,所以多个线程还是在交替执行,只不过因为CPU运行速度太快,我们感觉是在同时执行。
整个程序如果是一条回路,说明程序只有一个线程。
程序有两条回路以上同时向下执行,就是多线程。
Java中线程的使用
Java中使用线程有两种方式:
-
继承 Thread类
1、创建自定义类并继承 Thread类。
2、重写Thread类中的run方法,并编写该线程的业务逻辑代码。package com.southwind.java; public class MyThread extends Thread{ @Override public void run() { //定义业务逻辑 for (int i = 0;i < 1000;i ++){ System.out.println("--------MyTest"); } } }
3、使用:
package com.southwind.java; public class Test { public static void main(String[] args) { //开启两个子线程 MyThread myThread1 = new MyThread(); MyThread2 myThread2 = new MyThread2(); myThread1.start(); myThread2.start(); } }
注意:不能通过run方法来调用线程的任务,因为run方法调用相当于普通对象的执行,并不会去抢占CPU资源。
只有通过start方法才能开启线程,进而去抢占CPU资源,当某个线程抢占到CPU资源后,会自动调用run方法。 -
实现 Runnable接口
1、创建自定义类并实现Runnable接口。
2、实现run方法,编写该线程的业务逻辑代码。
package com.southwind.java;
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("====MyRunnable====");
}
}
}
package com.southwind.java;
public class MyRunnable2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("!!!!!MyRunnable2!!!!");
}
}
}
3、实现
package com.southwind.java;
public class Test {
public static void main(String[] args) {
//开启两个子线程
// MyThread myThread1 = new MyThread();
// MyThread2 myThread2 = new MyThread2();
// myThread1.start();
// myThread2.start();
//实例化Runnable
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();
MyRunnable2 runnable2 = new MyRunnable2();
Thread thread2 = new Thread(runnable2);
thread2.start();
}
}
线程和任务:
线程是去抢占CPU资源的,任务是具体执行业务逻辑的,线程内部会包含一个任务,线程启动(start),当抢占到资源之后,任务就开始执行(run)。
两种方式的区别:
1、MyThread,继承Thread类的方式,直接在类中重写run方法,使用的时候,直接实例化MyThread,start即可,因为 Thread内部存在Runnable。
1
2、MyRunnbale,实现Runnable接口的方法,在实现类中重写run方法,使用的时候,需要先创建 Thread对象,并将MyRunnable注入到Thread中,Thread.start。(推荐使用)
线程的状态
线程共有5种状态,在特定的情况下,线程可以在不同的状态之间切换,5种状态如下所示。
- 创建状态:实例化一个新的线程对象,还未启动。
- 就绪状态:创建好的线程对象调用start方法完成启动,进入线程池等待抢占CPU 资源。
- 运行状态:线程对象获取了CPU 资源,在一定的时间内执行任务。
- 阻塞状态:正在运行的线程暂停执行任务,释放所占用的CPU资源,并在解除阻塞状态之后也不能直接回到运行状态,而是重新回到就绪状态,等待获取 CPU资源。
- 终止状态:线程运行完毕或因为异常导致该线程终止运行。
线程调度
- 线程休眠
让当前线程暂停执行。从运行状态进入阻塞状态,将CPU资源让给其他线程池的调度方式,通过sleep()来实现。
sleep(long millis),调用时需要传入休眠时间,单位为毫秒
内部调用sleep方法:
package com.southwind.diaodu;
public class MyThread extends Thread{
@Override
public void run() {
for(int i = 0;i<10; i++) {
if (i ==5){
try {
sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(i+"-------MyThread");
}
}
}
package com.southwind.diaodu;
public class Test {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start();
}
}
外部调用sleep方法:
package com.southwind.diaodu;
public class MyThread2 extends Thread{
@Override
public void run() {
for (int i = 0;i<10;i++){
System.out.println("MyThread2====="+i);
}
}
}
package com.southwind.diaodu;
public class Test {
public static void main(String[] args) {
// MyThread thread = new MyThread();
// thread.start();
MyThread2 thread2 = new MyThread2();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread2.start();
}
}
需要注意的是休眠一定要放在启动之前。
如何让主线程休眠?直接通过静态方式调用sleep方法。
package com.southwind.diaodu;
public class Test2 {
public static void main(String[] args) {
for (int i = 0;i<10;i++){
if (i == 5){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(i+"+++++Test2+++++");
}
}
}
public static native void sleep(long millis) throws InterruptedException;
sleep是静态方法,可以通过类调用,也可以通过对象调用,方法定义抛出InterruptedException,InterruptedException继承Exception,外部调用是必需手动处理异常。
线程合并
合并是将指定的某个线程加入到当前线程中,合并为一个线程,由两个线程交替执行变成一个线程中的两个子线程顺序执行。
通过调用join方法来实现合并,具体如何合并?
线程甲和线程乙,线程甲执行到某个时间点的时候调用线程乙的join方法,则表示从当前时间点开始CPU资源被线程乙独占,线程甲进入
阻塞状态,直到线程乙执行完毕,线程甲进入就绪状态,等待获取CPU资源进入运行状态。
join方法重载,join()表示乙线程执行完毕之后才能执行其他线程,join(long millis)表示乙线程执行millis 毫秒之后,无论是否执行完毕,其他线程都可以和它争夺CPU资源。
join(long millis():
package com.southwind.diaodu;
public class JoinRunnable implements Runnable{
@Override
public void run() {
for (int i = 0;i<100;i++){
System.out.println(i+"-------JoinRunnable");
}
}
}
package com.southwind.diaodu;
public class JoinTest {
public static void main(String[] args) {
/**
*两个线程:主线程、join线程
* 主线程逻辑:当i==10时,join进程合并到主线程中
*/
JoinRunnable joinRunnable= new JoinRunnable();
Thread thread = new Thread(joinRunnable);
thread.start();
for (int i = 0;i<200;i++){
if (i == 10){
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(i+"main+++++++++");
}
}
}
join(long millis(3000):
package com.southwind.diaodu;
public class JoinRunnable2 implements Runnable{
@Override
public void run() {
for (int i = 0;i<20;i++){
try {
Thread.sleep(1000);//JoinRunnable延迟1秒输出一次
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(i+"-------JoinRunnable");
}
}
}
package com.southwind.diaodu;
public class JoinTest2 {
public static void main(String[] args) {
JoinRunnable2 joinRunnable = new JoinRunnable2();
Thread thread = new Thread(joinRunnable);
thread.start();
for (int i=0;i<100;i++){
if (i == 10){
try {
thread.join(3000);//join运行3秒后,其他线程可以开始抢占cpu资源
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(i+"++++++++main");
}
}
}
线程礼让
线程礼让是指在某个特定的时间点,让线程暂停抢占CPU资源的行为,运行状态/就绪状态—》阻塞状态,将CPU资源让给其他线程来使
用。
假如线程甲和线程乙在交替执行,某个时间点线程甲做出了礼让,所以在这个时间节点线程乙拥有了CPU资源,执行业务逻辑,但不代表线
程甲一直暂停执行。
线程甲只是在特定的时间节点礼让,过了时间节点,线程甲再次进入就绪状态,和线程乙争夺CPU资源。
通过yield方法实现。
package com.southwind.yield;
public class YieldThread1 extends Thread{
@Override
public void run() {
for (int i = 0;i<10;i++){
if (i == 5){
yield();
}
System.out.println(Thread.currentThread().getName()+"---"+i);
}
}
}
package com.southwind.yield;
public class YieldThread2 extends Thread{
@Override
public void run() {
for (int i = 0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"====="+i);
}
}
}
package com.southwind.yield;
public class Test {
public static void main(String[] args) {
YieldThread1 thread = new YieldThread1();
thread.setName("线程1");
YieldThread2 thread2 = new YieldThread2();
thread2.setName("线程2");
thread.start();
thread2.start();
}
}
线程中断
有很多种情况会造成线程停止运行:
线程执行完毕自动停止
线程执行过程中遇到错误抛出异常并停止线程执行过程中根据需求手动停止
Java中实现线程中断有如下几个常用方法:
-
public void stop()
-
public void interrupt()
-
public boolean isInterrupted()
stop方法在新版本的JDK已经不推荐使用,重点关注后两个方法。
interrupt是一个实例方法,当一个线程对象调用该方法时,表示中断当前线程对象。
每个线程对象都是通过一个标志位来判断当前是否为中断状态。
isInterrupted就是用来获取当前线程对象的标志位:true 表示清除了标志位,当前线程已经中断;false 表示没有清除标志位,当前对象没有中断。
当一个线程对象处于不同的状态时,中断机制也是不同的。
创建状态︰实例化线程对象,不启动。
package com.southwind.interrupted;
public class Test {
public static void main(String[] args) {
Thread thread = new Thread();
System.out.println(thread.getState());
thread.interrupt();
System.out.println(thread.isInterrupted());
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PqCfbmEh-1660298044428)(C:\Users\xwh666\AppData\Roaming\Typora\typora-user-images\image-20220810104953386.png)]
NEW表示当前线程对象为创建状态,false表示当前线程并未中断,因为当前线程没有启动,不存在中断,不需要清除标志位。
package com.southwind.interrupted;
public class Test2 {
public static void main(String[] args) {
// Thread thread = new Thread(new Runnable() {
// @Override
// public void run() {
// for (int i = 0;i<10;i++){
// System.out.println(i+"------main");
//
// }
// }
// });
// MyRunnable runnable = new MyRunnable();
// Thread thread = new Thread(runnable);
// thread.start();
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0;i<10;i++){
System.out.println(i+"-----main");
}
}
});
thread.start();
System.out.println(thread.getState());
System.out.println(thread.isInterrupted());
System.out.println(thread.getState());
}
}
线程同步
Java中允许多线程并行访问,同一时间段内多个线程同时完成各自的操作。
多个线程同时操作同一个共享数据时,可能会导致数据不准确的问题。
使用线程同步可以解决上述问题。
可以通过synchronized关键字修饰方法实现线程同步,每个Java对象都有一个内置锁,内置锁会保护使用synchronized关键字修饰的方法,要调用该方法就必须先获得锁,否则就处于阻塞状态。
非线程同步:
package com.southwind.test;
public class Account implements Runnable{
private static int num;
@Override
public void run() {
num++;
try {
Thread.currentThread().sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访问");
}
}
package com.southwind.test;
public class Test {
public static void main(String[] args) {
Account account = new Account();
Thread t1 = new Thread(account,"张三");
Thread t2 = new Thread(account,"李四");
t1.start();
t2.start();
}
}
线程同步:
package com.southwind.test;
public class Account implements Runnable{
private static int num;
@Override
public synchronized void run() {//加synchronized关键字,线程一进入就上锁
num++;
try {
Thread.currentThread().sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访问");
}
}
package com.southwind.test;
public class Test {
public static void main(String[] args) {
Account account = new Account();
Thread t1 = new Thread(account,"张三");
Thread t2 = new Thread(account,"李四");
t1.start();
t2.start();
for (int i = 0;i<10;i++){
Thread thread = new Thread(account,"线程"+i);
thread.start();
}
}
}
synchronized关键字可以修饰实例方法,也可以修饰静态方法,两者在使用的时候是有区别的。
package com.southwind.test;
public class SynchronizedTest {
public static void main(String[] args) {
for (int i = 0;i<5;i++){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SynchronizedTest.test();
}
});
thread.start();
}
}
public synchronized static void test(){
System.out.println("start......");
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end......");
}
}
synchronized修饰(实例)非静态方法
package com.southwind.test;
public class SynchronizedTest2 {
public static void main(String[] args) {
for (int i = 0;i<5;i++){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SynchronizedTest2 synchronizedTest2 = new SynchronizedTest2();
synchronizedTest2.test();
}
});
thread.start();
}
}
public synchronized void test(){
System.out.println("start......");
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end......");
}
}
给实例方法(非静态方法)添加synchronized关键字并不能实现线程同步。
线程同步的本质是锁定多个线程所共享的资源,synchronized还可以修饰代码块,会为代码块加上内置锁,从而实现同步。
package com.southwind.test;
public class SynchronizedTest3 {
public static void main(String[] args) {
for (int i = 0;i<5;i++){
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
SynchronizedTest3.test();
}
});
thread.start();
}
}
public static void test(){
synchronized (SynchronizedTest3.class) {//synchronized修饰代码块
System.out.println("start......");
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end......");
}
}
}
如何判断线程同步还是不同步?
找到关键点:锁定的资源在内存中是一份还是多份?一份大家需要排队,线程同步,多份(一人一份)。线程不同步。
无论是锁定方法还是锁定对象、锁定类。只需要分析这个方法、对象、类在内存中有几份即可。
对象一般是多份
类一定是一份
方法就看是静态还是非静态方法,静态一定是一份,非静态方法一般是多份
线程安全的单例模式
单例模式是一种常见的软件设计模式,核心思想是一个类只有一个实例对象。
栈内存只能存基本数据类型
单线程模式下的:
package com.southwind.singleton;
public class SigletonDemo {
private static SigletonDemo sigletonDemo;
private SigletonDemo(){
System.out.println("创建了 SingletonDemo...");
}
public static SigletonDemo getInstance(){
if (sigletonDemo == null){
sigletonDemo = new SigletonDemo();
}
return sigletonDemo;
}
}
package com.southwind.singleton;
public class Test {
public static void main(String[] args) {
// SigletonDemo sigletonDemo = SigletonDemo.getInstance();
// SigletonDemo sigletonDemo2 = SigletonDemo.getInstance();
// SigletonDemo sigletonDemo3 = SigletonDemo.getInstance();
for (int i = 0;i<10;i++){
SigletonDemo sigletonDemo = SigletonDemo.getInstance();
}
}
}
多线程模式下:
package com.southwind.singleton;
public class SigletonDemo {
private static SigletonDemo sigletonDemo;
private SigletonDemo(){
System.out.println("创建了 SingletonDemo...");
}
public synchronized static SigletonDemo getInstance(){//锁的范围太大了,需要改进
if (sigletonDemo == null){
sigletonDemo = new SigletonDemo();
}
return sigletonDemo;
}
}
package com.southwind.singleton;
public class Test2 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
SigletonDemo sigletonDemo = SigletonDemo.getInstance();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
SigletonDemo sigletonDemo = SigletonDemo.getInstance();
}
}).start();
}
}
双重检测,synchronized修饰代码块
1、线程同步是为了实现线程安全,如果只创建一个对象,那么线程就是安全的。
2、如果synchronized锁定的是多个线程共享的数据(同一个对象),那么线程就是安全的。
(帮助理解)
package com.southwind.singleton;
public class SigletonDemo {
private static SigletonDemo sigletonDemo;
private SigletonDemo(){
System.out.println("创建了 SingletonDemo...");
}
public static SigletonDemo getInstance(Integer i){
if (sigletonDemo == null){
synchronized (i){//锁的是同一个对象就是单例(值都是1,Integer看的是值一样就是同一个)
if (sigletonDemo==null){
sigletonDemo = new SigletonDemo();
}
}
}
return sigletonDemo;
}
}
package com.southwind.singleton;
public class Test2 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
Integer a = Integer.parseInt("1");
SigletonDemo sigletonDemo = SigletonDemo.getInstance(a);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
Integer b = Integer.parseInt("1");//虽然是b但是值是1,所以就是同一个对象
SigletonDemo sigletonDemo = SigletonDemo.getInstance(b);
}
}).start();
}
}
3、volatile的作用是可以使内存中的数据对线程可见。
package com.southwind.singleton;
public class SigletonDemo {
private volatile static SigletonDemo sigletonDemo;
private SigletonDemo(){
System.out.println("创建了 SingletonDemo...");
}
public static SigletonDemo getInstance(){
if (sigletonDemo == null){
synchronized (SigletonDemo.class){//最终版
if (sigletonDemo==null){
sigletonDemo = new SigletonDemo();
}
}
}
return sigletonDemo;
}
}
死锁
前提:一个线程完成业务需要同时访问两个资源。
死锁:多个线程同时在完成业务,出现争抢资源的情况。
炒一锅菜(一个线程)需要两个锅(两个资源),A拿了1锅,B拿了2锅,两边都炒不成,谁都不让
资源类:
package com.southwind.deadlock;
public class DeadLockRunnable implements Runnable {
//编号
public int num;
//资源
private static Chopsticks chopsticks1 = new Chopsticks();
private static Chopsticks chopsticks2 = new Chopsticks();
/**
* num = 1,拿到chopsticks1,等待chopsticks2
* num = 2,拿到chopsticks2,等待chopsticks1
*/
@Override
public void run() {
if (num == 1) {
System.out.println(Thread.currentThread().getName() + "拿到chopsticks1,等待chopsticks2");
synchronized (chopsticks1) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (chopsticks2) {
System.out.println(Thread.currentThread().getName() + "用餐完毕");
}
}
}
if(num ==2) {
System.out.println(Thread.currentThread().getName() + "拿到chopsticks2,等待chopsticks1");
synchronized (chopsticks2) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (chopsticks1) {
System.out.println(Thread.currentThread().getName() + "用餐完毕");
}
}
}}}
package com.southwind.deadlock;
public class DeadLockTest {
public static void main(String[] args) {
DeadLockRunnable deadLockRunnable1 = new DeadLockRunnable();
deadLockRunnable1.num = 1;
DeadLockRunnable deadLockRunnable2 = new DeadLockRunnable();
deadLockRunnable2.num = 2;
new Thread(deadLockRunnable1,"张三").start();
new Thread(deadLockRunnable2,"李四").start();
}
}
如何破解死锁?
不要让多线程并发
package com.southwind.deadlock;
public class DeadLockTest {
public static void main(String[] args) {
DeadLockRunnable deadLockRunnable1 = new DeadLockRunnable();
deadLockRunnable1.num = 1;
DeadLockRunnable deadLockRunnable2 = new DeadLockRunnable();
deadLockRunnable2.num = 2;
new Thread(deadLockRunnable1,"张三").start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(deadLockRunnable2,"李四").start();
}
}
使用lambda表达式简化代码开发
package com.southwind.demo;
public class Test2 {
public static void main(String[] args) {
new Thread(()->{
for (int i = 0;i<100;i++){
System.out.println("+++++++++Runnable");
System.out.println("++++-----Runnable");
System.out.println("+++++====Runnable");
}
}).start();
}
}
package com.southwind.demo;
public class Test2 {
public static void main(String[] args) {
new Thread(()->{for (int i = 0;i<100;i++) System.out.println("+++++++++Runnable");}).start();
new Thread(()->{for (int i = 0;i<100;i++) System.out.println("++++-----Runnable");}).start();
new Thread(()->{for (int i = 0;i<100;i++) System.out.println("++++=====Runnable");}).start();
}
}
Lock
JUC:java.util.concurrent
Lock是一个接口,用来实现线程同步的,功能与synchronized一样。
Lock使用频率最高的实现类是ReentrantLock(重入锁),可以重复上锁
package com.southwind.lock;
import com.southwind.test.Account;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
Account account = new Account();
new Thread(account,"A").start();
new Thread(account,"B").start();
}
}
class A implements Runnable{
private static int num;
private Lock lock = new ReentrantLock();
@Override
public void run() {
lock.lock();
num++;
System.out.println(Thread.currentThread().getName()+"是当前的第"+num+"位访客");
lock.unlock();
}
}
实现资源和Runnable接口的解耦合。
package com.southwind.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Test {
public static void main(String[] args) {
Account account = new Account();
new Thread(()->{
account.count();
},"A").start();
new Thread(()->{
account.count();
},"B").start();
// new Thread(account,"A").start();
// new Thread(account,"B").start();
}
}
class Account{
private int num;
private Lock lock = new ReentrantLock();
public void count(){
lock.lock();
num++;
System.out.println(Thread.currentThread().getName()+"是第"+num+"位访客");
lock.unlock();
}
}
重入锁
JUC:java.util.concurrent
java并发编程工具包,java官方提供的一套专门用来处理并发编程的工具集合(接口+类)
并发:单核CPU,多个线程“同时“运行,实际是交替执行,只不过速度太快,看起来是同时执行。
两个厨师一口锅
并行:多核CPU,真正的多个线程同时运行。
两个厨师两口锅
重入锁是JUC使用频率非常高的一个类ReentrantLock
ReentrantLock就是对Synchronized的升级,目的也是为了实现线程同步。
- ReentrantLock是一个类,synchronized是一个关键字
- ReentrantLock是JDK实现,synchronized是JVM实现
- ReentrantLock手动释放锁,synchronized自动释放锁
公平锁:线程同步时,多个线程排队,依次执行
非公平锁:线程同步时,可以插队
- 继承Thread
- 实现Rnnable
实现Runnable的耦合度更低
package com.southwind.reentrantLock;
import com.southwind.reentrantLock.Account;
import java.util.concurrent.TimeUnit;
public class Test {
public static void main(String[] args) {
Account account = new Account();
// new Thread(new Runnable() {
// @Override
// public void run() {
// account.count();
// }
// },"A").start();
new Thread(()->{ //lambda表达式是上面的简写
account.count();
},"A").start();
new Thread(()->{
account.count();
},"A").start();
}
}
class Account{
private static int num;
public void count(){
num++;
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"是当前第"+num+"位访客");
}
}
Tips
package com.southwind.reentrantLock;
import com.southwind.reentrantLock.Account;
import java.util.concurrent.TimeUnit;
public class Test {
public static void main(String[] args) {
Account account = new Account();
// new Thread(new Runnable() {
// @Override
// public void run() {
// account.count();
// }
// },"A").start();
new Thread(()->{ //lambda表达式是上面的简写
account.count();
},"A").start();
new Thread(()->{
account.count();
},"A").start();
}
}
class Account{
private static Integer num = 0;//要设定初始值否则会空指针异常
private static Integer id = 0;
// public synchronized void count(){//可以加synchronized关键字
public void count(){
synchronized (id){//可以锁Account.class类,也可以锁id(因为id不变,而num++了所以会变
num++;
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"是当前第"+num+"位访客");
}
}
}
锁id可以同步,锁num不能同步原因是什么?
synchronized必须锁定唯一的元素才可以实现同步
id不变所以是唯一的元素,而num++了,num锁指向的引用一直在变,所以不是唯一的元素,肯定无法实现同步。
ReentrantLock
package com.southwind.reentrantLock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class Test3 {
public static void main(String[] args) {
Account3 account3 = new Account3();
new Thread(()->{
account3.count();
},"A").start();
new Thread(()->{
account3.count();
},"B").start();
}
}
class Account3{
private static int num;
private ReentrantLock reentrantLock= new ReentrantLock();
public void count(){
//上锁
reentrantLock.lock();
num++;
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"当前的第"+num+"位访客");
//解锁
reentrantLock.unlock();
}
}
- Lock上锁和解锁都需要开发者手动完成
- 可以重复上锁,上几把锁就要解几把锁