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() 来控制线程，方法不再推荐使用
