java线程
一、线程的相关概念
-
程序(program)
是为了完成特定任务,用某种语言进行编写的一组指令的集合。简单的说:就是我们写的代码
-
进程
1、进程是指运行中的程序,比如我们使用QQ,就启动一个进程,操作系统就会为该进程分配内存空间。当我们使用迅雷,又启动了一个进程,操作系统将为迅雷分配新的内存空间
2、进程是程序的一次执行过程,或是正在运行的一个程序。是动态过程:有它自身的产生、存在和消亡的过程
-
线程
1、线程是由进程创建的,是进程的一个实体
2、一个进程可以拥有多个线程
-
其他相关概念
1、单线程:同一个时刻,只允许执行一个线程
2、多线程:同一时刻,可以执行多个线程,比如:一个qq进程,可以打开多个聊天窗口,一个迅雷进程,可以同时下载多个文件
3、并发:同一个时刻,多个任务交替执行,造成一种“貌似同时”的错觉,简单的说,单核cpu实现的多个任务就是并发
4、并行:同一个时刻,多个任务同时执行。多核cpu可以实现并行。并发金和并行可以同时存在
二、线程的创建
1、继承Thread类,重写run()方法
类图关系
代码案例:
public class Thread01 {
public static void main(String[] args) throws InterruptedException {
/**
* 1、请编写一个程序,开启一个线程,该线程每隔一秒,在控制台输出“ hello,world!”
* 2、对上题改进:当输出80次 ”hello,world“,结束该线程
* 3、使用JConsole 监控线程执行情况,并画出程序示意图
*/
//创建一个Cat对象,当做线程使用
Cat cat = new Cat();
cat.start();
//说明:当main线程启动一个子线程时,也就是Thread-0子线程,主线程不会阻塞,会继续执行下面的方法
for (int i = 0; i < 10; i++) {
System.out.println("主线程:" + Thread.currentThread().getName() + " 正在打印: 我是主线程");
Thread.sleep(1000);
}
}
}
//继承 Thread 类
//1、当一个类继承了Thread,该类就可以当做线程使用
//2、一般我们会重写run方法,写上自己的逻辑
//3、run Thread类 实现了 Runnable 接口的run方法
class Cat extends Thread{
int time = 0;
//重写run方法
@Override
public void run() {
while (time < 10){
//线程名称
System.out.println("线程名称:=====>"+Thread.currentThread().getName() + " 正在打印:====> hello world!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
time++;
}
}
}
1、当运行该程序时,就相当于启动了一个进程,
2、启动进程过后,就会马上进入这个主方法,也就是main方法,进入main方法,就是相当于开启了一个主线程,也就是进程里面开启了一个主线程(main线程)
3、在这个main主线程里面,new了一个Cat,因为这个Cat继承了Thread,所以是一个线程类,Cat调用 start() 方法,就是相当于在main主线程中又开启了一个新的线程,Cat线程
4、当main线程启动一个子线程时,也就是Thread-0子线程,主线程不会阻塞,会继续执行下面的方法,这时的主线程和子线程都是交互执行的
5、当主线程执行完并退出时,子线程还在运行,这样并不会造成这个进程的结束(这个进程也就是应用程序)
6、主线程可以开启多个子线程,子线程也可以开启多个子线程,当最后一个子线程结束后,整个进程才会退出
2、实现Runnable接口
说明:
1、java是单继承的,在某些情况下一个类可能已经继承了某个父类,这时在用继承Thread方法来创建线程显然是不可能了
2、java设计者们提供了另一个方式创建线程,就是通过实现Runnable接口来创建线程
代码案例:
三、start() 和 run()
run() 方法只是一个普通的方法,在main主方法中调用线程的 run() 方法,只会是等待被调用的线程的 run() 方法执行完后才会再执行下一行代码,没有真正的启动一个线程,线程类调用的 run() 方法所在的线程是主线程,也就是main线程
start() 才会真正的启动线程
源码:
//首先调用start方法
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0(); //这个方法才是真正的启动线程
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
真正实现多线程的是 start0() 这个方法
//start0()是一个 本地方法,是JVM进行调用,底层是c/c++
//真正实现多线程的是 start0() 这个方法,而不是 run() 方法
private native void start0();
原理图:
start() 方法调用 start0() 方法后,该线程并不一定会立马执行,只是将线程变成了可运行状态,具体什么时候执行,取决于CPU,由CPU统一调度。
静态代理测试代码:
public class Thread02 {
public static void main(String[] args) {
//编写程序,该程序每隔一秒,在控制台输出 “hi” ,当输出10次后,自动退出,请使用实现Runnable接口方式实现,这里是静态代理
//Dog dog = new Dog();
//创建一个 Thread 对象,把dog(实现了Runnable接口),放入new Thread(dog)
//这里使用了一个设计模式,代理模式,静态代理
//Thread t = new Thread(dog);
//t.start();
Tiger tiger = new Tiger();
ThreadProxy threadProxy = new ThreadProxy(tiger);
threadProxy.start();
}
}
//测试
class Animal {}
class Tiger extends Animal implements Runnable {
int time = 0;
@Override
public void run() {
while (time < 10){
System.out.println("老虎叫了" + (++time) + "声");
}
}
}
//模拟代理模式
//可以将ThreadProxy看做一个代理类
//模拟了一个最简单的Thread类
class ThreadProxy implements Runnable {
//属性,类型是 Runnable
private Runnable target = null;
@Override
public void run() {
if (target != null){
target.run(); //动态绑定(运行类型是 Tiger)
}
}
//创建一个构造器,将实现了Runnable对象传进来
public ThreadProxy(Runnable target) {
this.target = target;
}
//实现start方法
public void start(){
//这个方法是真正实现了多线程的方法
start0();
}
public void start0(){
run();
}
}
//通过实现 Runnable 接口实现线程类
class Dog implements Runnable{
int time = 0;
//重写run方法
@Override
public void run() {
while (true) {
System.out.println("hi" + (++time) + " 线程名称:" + Thread.currentThread().getName());
try {
//休眠1秒
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (time == 10){
break;
}
}
}
}
四、多线程执行
要求:
请编写一个 程序,创建两个线程,一个线程每隔一秒输出 “hello,world”,输出10次,一个线程每隔1秒输出 “hi”,输出5次,退出
public class Thread03 {
public static void main(String[] args) {
//主线程执行后,下面的子线程不会造成阻塞所以主线程执行完成后,直接结束
//但是子线程还在运行,所以这个主进程还在运行,主线程结束并不会影响主进程的运行
T1 t1 = new T1();
T2 t2 = new T2();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
thread1.start();
thread2.start();
}
}
//每隔一秒输出 “hello,world”,输出10次退出
class T1 implements Runnable{
int time = 0;
@Override
public void run() {
while (time < 10){
System.out.println("hello,world " + (++time));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//每隔一秒输出 “hi”,输出5次退出
class T2 implements Runnable{
int time = 0;
@Override
public void run() {
while (time < 5){
System.out.println("hi " + (++time));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
五、Thread 和 Runnable 的区别
1、从java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本质没有区别,从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口
底层都是通过 start()方法 去调用 start0()方法
2、实现Runnable接口方式更加适合多个线程共享一个资源的情况,并且避免了单继承的限制
理解:当创建了一个线程类,继承Runnable接口,那么可以开启两个线程进行去同时执行这个线程类,这样两个线程就可以共享一个资源
T1 t1 = new T1();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t1);
thread1.start();
thread2.start();
六、模拟售票
public class SellTicket {
public static void main(String[] args) {
//Thread 测试
// SellTicket01 s1 = new SellTicket01();
// SellTicket01 s2 = new SellTicket01();
// SellTicket01 s3 = new SellTicket01();
//启动
// s1.start();
// s2.start();
// s3.start();
//Runnable 测试
SellTicket02 sellTicket02 = new SellTicket02();
//启动 操作的是同一个对象
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
new Thread(sellTicket02).start();
}
}
//使用 Thread 方式 互斥同步的问题
class SellTicket01 extends Thread{
//票数,让多个线程共享
private static int ticketNum = 100;
@Override
public void run() {
while (true){
//如果卖完了,直接退出
if (ticketNum <= 0){
System.out.println("售票结束....");
break;
}
//没卖完,休眠50毫秒继续卖
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() +
" 卖出了1张票,剩余票数 ===> " + (--ticketNum));
}
}
}
//通过 Runnable 接口实现
class SellTicket02 implements Runnable{
//票数,让多个线程共享
private int ticketNum = 100;
@Override
public void run() {
while (true){
//如果卖完了,直接退出
if (ticketNum <= 0){
System.out.println("售票结束....");
break;
}
//没卖完,休眠50毫秒继续卖
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() +
" 卖出了1张票,剩余票数 ===> " + (--ticketNum));
}
}
}
出现的共同问题:
当出现三个线程共享一个资源(票数)
当票数只剩2张,当t1先进行判断时,发现还有2张票,但是在t1没有来得及进行售票操作时,t2进来,此时的票数在t1没有减去1张前,还有2张,就在t2和t1正在往下执行售票操作时,t3进来,判断发现票数还没有减去,还有2张,也就执行售票操作,最终导致的结果是t1和t2已经完成了售票操作,分别卖出1张,那么t3就没有票,但是也执行了售票操作,导致票数为负数,超过额定的票数
七、线程退出和中断
1、线程退出
基本说明:
1、当线程完成任务后,会自动退出
2、还可以通过使用变量来控制 run 方法退出的方式停止线程,即通知方式
示例代码:
要求:启动一个线程t,要求在main线程中去停止线程t
public class ThreadExit_ {
public static void main(String[] args) throws InterruptedException {
T t1 = new T();
t1.start();
//如果希望main线程去终止t1这个线程,必须修改loop,让t1退出run方法,从而终止 t1 -> 通知方法
//让main线程休眠5秒,再去通知t1子线程
Thread.sleep(5000);
t1.setLoop(false);
}
}
class T extends Thread{
int count = 0;
//设置一个变量
private boolean loop = true;
//通过set方式修改 loop 的值,从而达到将 run 方法停止的目的
public void setLoop(boolean loop) {
this.loop = loop;
}
@Override
public void run() {
while (loop){
System.out.println("我是子线程 " + Thread.currentThread().getName() + (++count));
try {
//休眠50毫秒
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
2、线程中断
线程中断就是将正在休眠的线程提前中断,打断线程休眠,将线程唤醒,打断的线程将会重新进入 while 循环,再次执行
public class ThreadInterrupt_ {
public static void main(String[] args) throws InterruptedException {
A a = new A();
//开启子线程
a.start();
//主线程打印5次 “hi”,中断子线程的休眠
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("hi " + i);
}
//中断子线程的休眠
a.interrupt();
}
}
//自定义线程类
class A extends Thread{
@Override
public void run() {
while (true){
for (int i = 0; i < 100; i++) {
//Thread.currentThread().getName() 获取当前线程的名称,如果设置了名称,就显示该名称,
// 如果没有设置,就显示默认名称
System.out.println(Thread.currentThread().getName() + " 吃包子~~~ " + i);
}
try {
System.out.println(Thread.currentThread().getName() + " 休眠中~~~ ");
Thread.sleep(200000);
} catch (InterruptedException e) {
// InterruptedException 中断异常
//当线程执行到一个interrupt方法时,就会catch一个异常,可以加入自己的业务代码
System.out.println(Thread.currentThread().getName() + " 被interrupt了~~~ ");
}
}
}
}
八、线程的常用方法
1、基本方法
1、setName //设置线程名称,使之与参数name相同
2、getName //返回该线程的名称
3、start //使该线程开始执行;java虚拟机底层调用该线程的 start0() 方法
4、run //调用线程对象 run 方法
5、setPriority //更改线程优先级
6、getPriority //获取线程优先级
7、sleep //在执行的毫秒数内让当前正在执行的线程休眠(暂停执行)
8、interrupt //中断线程
需要注意的细节:
1、start 底层会创建新的线程,调用 run,run就是一个简单的方法调用,不会启动新线程
2、线程优先级的范围
3、interrupt,中断线程,但是并没有真正的结束线程。所以一般用于中断正在休眠的线程
4、sleep:线程的静态方法,使当前线程休眠
源码,优先级常量:
/**
* The minimum priority that a thread can have.
*/
public final static int MIN_PRIORITY = 1; //优先级最低
/**
* The default priority that is assigned to a thread.
*/
public final static int NORM_PRIORITY = 5; //正常的优先级
/**
* The maximum priority that a thread can have.
*/
public final static int MAX_PRIORITY = 10; //优先级最高
示例代码:
public class ThreadMethod01 {
public static void main(String[] args) throws InterruptedException {
//测试相关方法
T t = new T();
//设置线程名称 setName
t.setName("猪八戒");
//设置优先级
t.setPriority(Thread.MIN_PRIORITY);
//开启线程
t.start();
//输出线程名称
System.out.println("线程名称:" + Thread.currentThread().getName());
//主线程打印5次 “hi”,然后中断子线程的休眠
for (int i = 0; i < 5; i++) {
Thread.sleep(1000);
System.out.println("hi " + i);
}
//中断子线程的休眠
t.interrupt();
}
}
//自定义线程类
class T extends Thread{
@Override
public void run() {
while (true){
for (int i = 0; i < 100; i++) {
//Thread.currentThread().getName() 获取当前线程的名称,如果设置了名称,就显示该名称,
// 如果没有设置,就显示默认名称
System.out.println(Thread.currentThread().getName() + " 吃包子~~~ " + i);
}
try {
System.out.println(Thread.currentThread().getName() + " 休眠中~~~ ");
Thread.sleep(200000);
} catch (InterruptedException e) {
// InterruptedException 中断异常
//当线程执行到一个interrupt方法时,就会catch一个异常,可以加入自己的业务代码
System.out.println(Thread.currentThread().getName() + " 被interrupt了~~~ ");
}
}
}
}
2、线程礼让和线程插队
1、yield:线程礼让。让出cpu,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException {
B b = new B();
b.start();
//让主线程输出 20次 hi,每隔1秒
for (int i = 0; i <= 20; i++) {
Thread.sleep(1000);
System.out.println("主线程输出 hi" + i);
//判断主线程是否到了第5次,让子线程先执行,执行完成后,主线程再执行
if (i == 4){
//线程礼让,不一定成功,这是一个静态方法,让主线程先执行
Thread.yield();
}
}
}
}
//创建子线程
class B extends Thread{
int time = 0;
@Override
public void run() {
//让子线程循环输出20次 hello,每隔1秒
while (true){
if (time == 20){
break;
}
try {
System.out.println("子线程输出 hello " + (++time));
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
2、join:线程插队。插队的线程一旦插队成功,则肯定先执行完插入的线程所有任务
案例:
创建一个子线程,每隔1s输出 hello ,输出20次,主线程每隔1s ,输出 hi,输出 20 次
要求:
两个线程同时执行,当主线程输出 5 次后,就让子线程运行完毕,主线程再继续
join代码示例:
public class ThreadMethod02 {
public static void main(String[] args) throws InterruptedException {
B b = new B();
b.start();
//让主线程输出 20次 hi,每隔1秒
for (int i = 0; i <= 20; i++) {
Thread.sleep(1000);
System.out.println("主线程输出 hi" + i);
//判断主线程是否到了第5次,让子线程先执行,执行完成后,主线程再执行
if (i == 4){
//让子线程先执行
//线程插队
b.join();
}
}
}
}
//创建子线程
class B extends Thread{
int time = 0;
@Override
public void run() {
//让子线程循环输出20次 hello,每隔1秒
while (true){
if (time == 20){
break;
}
try {
System.out.println("子线程输出 hello " + (++time));
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
3、用户线程和守护线程
基本介绍:
1、用户线程:也叫做工作线程,当线程的任务执行完或者通知方式结束
2、守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束
3、常见的守护线程:垃圾回收机制
制作一个守护线程:
public class ThreadMethod03 {
public static void main(String[] args) throws InterruptedException {
//声明守护线程
MyDeamonThread mt = new MyDeamonThread();
//将子线程设置为守护线程
//一旦所有的线程结束工作,那么守护线程也将会退出工作
mt.setDaemon(true);
//启动守护线程
mt.start();
//主线程循环
for (int i = 0; i <= 10; i++) {
Thread.sleep(1000);
System.out.println("我是主线程,我正在工作...");
}
}
}
//线程类
class MyDeamonThread extends Thread{
@Override
public void run() {
//等价于while循环,无限循环
for (; ;){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("我是守护线程,我正在守护.....");
}
}
}
注意点:
需要将 mt.setDaemon(true) 在线程启动之前设置,否则就会抛出异常
九、线程的生命周期
官方文档的生命周期:
-
NEW
尚未启动的线程处于此状态
-
RUNNABLE
在java虚拟机中执行的线程处于此状态
-
BLOCKED
被阻塞等待监视器锁定的线程处于此状态
-
WAITING
在等待另一个线程执行特定动作的线程处于此状态
-
TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
-
TERMINATED
已经退出的线程处于此状态
线程生命周期转换图:
说明:
1、当创建一个线程,也就是new一个线程出来过后,首先进入一个NEW状态,一旦调用了 start() 方法,就进入 Runnable状态(可运行状态),Runnable状态细化的话可分为两个状态,Ready状态(就绪状态)和 Running(运行状态)
2、线程是否被执行,还要取决于线程是否被调度器选中执行,一旦被调度器选中,那么就从Ready状态(就绪状态),那么线程就进入Running状态(运行状态),如果线程运行结束,那么就会进入Teminated状态(终止状态),相当于线程挂了
3、如果线程在 Runnable状态(可运行状态)调用了 Tread.sleep(time)、o.wait(time)、t.join(time)、LockSupport.parkNanos() 这些方法,就会进入TimeWaiting状态(超时等待状态),等待时间结束后在进入 Runnable状态(可运行状态)
4、如果线程在 Runnable状态(可运行状态)调用了 o.wait()、t.join()、LockSupport.park() 这些方法,那么就会进入 Waiting状态(等待状态),通过线程执行 o.notify()、o.notifyAll()、LockSupport.unpark() 这些方法重新进入 Runnable状态(可运行状态)
5、当线程在Runnable状态(可运行状态)要去获取一把锁或者进入一个同步代码块时,会先进入 Blocked 状态(阻塞状态),获取锁后才会重新进入Runnable状态(可运行状态),等待 Running
在官方文档中有6种状态,但是在Runnable状态(可运行状态)线程是否在运行,要取决于调度器,由内核的调度器来执行,因此还可再细分为 Ready状态(就绪状态)和 Running状态(运行状态)
实例代码:
public class ThreadState_ {
public static void main(String[] args) throws InterruptedException {
Td td = new Td();
//线程启动前状态
System.out.println(td.getName() + " 线程启动前的状态 " + td.getState());
td.start();
//循环线程启动后的状态
//Thread.State.TERMINATED != td.getState() 判断当前线程状态是否为终止状态
while (Thread.State.TERMINATED != td.getState()){
//当线程状态不为终止状态,就打印线程的实时状态
System.out.println(td.getName() + " 线程正在运行的状态 " + td.getState());
Thread.sleep(500); //让主线程休眠再打印
}
//线程停止的状态
System.out.println(td.getName() + " 线程停止的状态 " + td.getState());
}
}
class Td extends Thread{
@Override
public void run() {
while (true){
for (int i = 0; i < 10; i++) {
System.out.println("hi~ " + i);
try {
//这里的休眠会让线程进入 超时等待状态 TIMED_WAITING
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//for循环结束后直接退出子线程
break;
}
}
}
十、线程同步机制
说明:
1、在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性
2、也可以这里理解:线程同步,即当有一个线程对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作
同步实现具体方法 – synchronized
1、同步代码块,对象锁
synchronized(对象){ //得到对象的锁,才能操作同步代码
//需要被同步代码
}
2、synchronized( 还可以放在方法声明中,表示整个方法为同步方法
public synchronized void method(String name){
//需要被同步的代码
}
3、理解:当一个人去上厕所前,进入厕所要先关门,上完厕所出来后,把门打开才能让下一个人进去上厕所
4、使用 synchronized 解决售票问题
public class SellTicket {
public static void main(String[] args) {
SellTicket01 sk = new SellTicket01();
new Thread(sk).start();
new Thread(sk).start();
new Thread(sk).start();
}
}
//通过 Runnable 接口实现
class SellTicket01 implements Runnable{
//票数,让多个线程共享
private int ticketNum = 100;
//控制while循环
private boolean loop = true;
//public synchronized void sell(){} 通过synchronized加上一把锁,那么这个方法就是一个同步方法,这时,这个锁是在this对象上(SellTicket01)
public synchronized void sell(){ // 同步方法,在同一时刻,只能有一个线程来操作这个卖票方法
//如果卖完了,直接退出
if (ticketNum <= 0){
System.out.println("售票结束....");
loop = false;
return;
}
//没卖完,休眠50毫秒继续卖
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() +
" 卖出了1张票,剩余票数 ===> " + (--ticketNum));
}
@Override
public void run() {
while (loop){
sell(); //这个sell方法是一个同步方法
}
}
}
同步原理:
比如有三个线程 t1、t2、t3,刚开始会去争夺锁,锁在对象上,当 t1 抢到这把锁,进去操作相关的代码,当操作完后, t1 就会把这把锁放回去,然后再去与 t2、t3 争夺这把锁,synchronized 是一把非公平锁,每个线程都可以去争夺
十一、互斥锁
说明:
1、java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性
2、每个对象都对应于一个可称为 互斥锁 的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象
3、关键字 synchronized 来与对象的互斥锁联系。当某个对象用 synchronized 修饰时,表明该对象在任一时刻只能由一个线程访问
4、同步的局限性:导致程序的执行效率要降低
5、同步方法(非静态的)的锁可以是this,也可以是其他对象(要求是同一个对象)
6、同步方法(静态的)的锁为当前类本身
//同步方法(静态的)的锁为当前类本身
//1、public synchronized static void method(){} 锁是加在 SellTicket01.class上的,因为这个method01是一个静态方法
public synchronized static void method01(){}
//2、如果是静态方法中,实现一个同步代码块,那么synchronized中就是这个类的 .class
public static void method02(){
synchronized (SellTicket01.class){}
}
将锁加在代码块上:
public class SellTicket {
public static void main(String[] args) {
SellTicket01 sk = new SellTicket01();
new Thread(sk).start();
new Thread(sk).start();
new Thread(sk).start();
}
}
//通过 Runnable 接口实现
class SellTicket01 implements Runnable{
//票数,让多个线程共享
private int ticketNum = 100;
//控制while循环
private boolean loop = true;
//可以用这个object替代当前synchronized中的this,因为这三个线程操作的都是同一个类
//synchronized (object)
Object object = new Object();
//同步方法(静态的)的锁为当前类本身
//1、public synchronized static void method(){} 锁是加在 SellTicket01.class上的,因为这个method01是一个静态方法
public synchronized static void method01(){}
//2、如果是静态方法中,实现一个同步代码块,那么synchronized中就是这个类的 .class
public static void method02(){
synchronized (SellTicket01.class){}
}
public void sell(){ // 同步方法,在同一时刻,只能有一个线程来操作这个卖票方法
//同步代码块 synchronized
synchronized (this){
//如果卖完了,直接退出
if (ticketNum <= 0){
System.out.println("售票结束....");
loop = false;
return;
}
//没卖完,休眠50毫秒继续卖
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() +
" 卖出了1张票,剩余票数 ===> " + (--ticketNum));
}
}
@Override
public void run() {
while (loop){
sell(); //这个sell方法是一个同步方法
}
}
}
注意事项和细节:
1、同步方法如果没有使用 statis 修饰,默认锁的对象为 this
2、如果方法使用statis修饰,默认锁对象为 当前类.class
3、实现的落地步骤:
- 需要分析上锁的代码
- 选择同步代码块或同步方法
- 要求多个线程的锁对象为同一个即可
/**
* 当调用该线程时,肯定是如下场景
* new SellTicket02().start()
* new SellTicket02().start()
* 这样这个同步所就无法实现,原因是每次都是 new 一个新的 SellTicket02
* 而不是操作同一个SellTicket02对象,所以 this 的指向都是新的对象,无法锁住
* 最后失效
*/
class SellTicket02 extends Thread{
private static int ticketNum = 100; //多个线程共享
public void method(){
synchronized (this){
System.out.println("hello-");
}
}
@Override
public void run() {
super.run();
}
}
十二、线程死锁
基本介绍:
多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,在编程是一定要避免死锁的发生
发生死锁实例代码:
public class DeadLock_ {
public static void main(String[] args) {
//线程A启动
DeadLockDemo A = new DeadLockDemo(true);
A.setName("A线程 ");
//线程B启动
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B线程 ");
A.start();
B.start();
}
}
class DeadLockDemo extends Thread{
//为保证多线程情况下,共享一个 object对象,这里使用static修饰
static Object o1 = new Object();
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
/**
* 业务逻辑分析
* 1、如果flag为true,线程A 就会先持有 o1 这个对象锁,然后尝试去获取 o2 对象锁
* 2、如果 线程A 得不到 o2 对象锁,就会进入 Blocked 状态(阻塞状态)
* 3、如果flag为false,线程B 就会先得到 o2 这个对象锁,然后尝试获取 o1 对象锁
* 4、如果 线程B 拿不到 o1 对象锁,就会进入 Blocked 状态(阻塞状态)
*/
if (flag){
synchronized (o1){ //synchronized加上对象互斥锁,下面就是同步对象
System.out.println(Thread.currentThread().getName() + " 进入o1 ");
synchronized (o2){
System.out.println(Thread.currentThread().getName() + " 进入o2 ");
}
}
}else{
synchronized (o2){
System.out.println(Thread.currentThread().getName() + " 进入o3 ");
synchronized (o1){
System.out.println(Thread.currentThread().getName() + " 进入o4 ");
}
}
}
}
}
十三、释放锁
基本介绍:
1、当线程的同步方法、同步代码块执行结束
2、当线程在同步代码块、同步方法中遇到 break、return
3、当线程在同步代码块、同步方法中出现未处理的 Error 或 Exception,导致异常结束
4、当线程在同步代码块、同步方法中执行了线程对象的 wait() 方法,当前线程暂停,并释放锁
下面的操作不会释放锁:
1、线程执行同步代码块或者同步方法时,程序调用 Thread.sleep()、Thread.yield() 方法暂停当前线程的执行,不会释放锁
2、线程执行同步代码块时,其他线程调用了该线程的 suspend() 方法将该线程挂起,该线程不会释放锁,提示:应尽量避免使用 suspend() 和 resume() 来控制线程,方法不再推荐使用