Java 多线程 —— 同步代码块（解决线程安全问题)

给大家的福利

零基础入门

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

同时每个成长路线对应的板块都有配套的视频提供：

因篇幅有限，仅展示部分资料

网络安全面试题

绿盟护网行动

还有大家最喜欢的黑客技术

网络安全源码合集+工具包

所有资料共282G，朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》，可以扫描下方二维码领取（如遇扫码问题，可以在评论区留言领取哦）~

需要体系化学习资料的朋友，可以加我V获取：vip204888 （备注网络安全）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

火车站延迟卖票问题满足这三个条件，因此造成了线程安全问题，而前两条都不可避免，那么就可以着手于破坏掉第三个条件，让线程安全问题不成立。

思路是将多条语句包装成一个同步代码块，当某个线程执行这个同步代码块的时候，就跟原子性一样，其他的线程不能抢占CPU，只能等这个同步代码块执行完毕。

解决办法：

1. synchronized —— 自动锁

2. lock —— 手动锁

synchronized

synchronized(对象){

//可能会发生线程安全问题的代码

}

//这里的对象可以是任意对象，我们可以用 Object obj = new Object()里面的obj放入括号中

使用synchronized的条件：

1. 必须有两个或两个以上的线程

2. 同一时间只有一个线程能够执行同步代码块

3. 多个线程想要同步时，必须共用同一把锁

synchronized(对象)括号里面的对象就是一把锁

使用synchronized的过程：

1. 只有抢到锁的线程才可以执行同步代码块，其余的线程即使抢到了CPU执行权，也只能等待，等待锁的释放。

2. 代码执行完毕或者程序抛出异常都会释放锁，然后还未执行同步代码块的线程争抢锁，谁抢到谁就能运行同步代码块。

同步代码块

因此，修改后的代码为：

package test.MyThread.ticketDemo;

public class RunnableThread implements Runnable{

private int ticket = 100;

Object obj = new Object();

@Override

public void run(){

while(true){

synchronized (obj) {

if (ticket > 0) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + “正在出售第 " + ticket + " 张票”);

ticket–;

}

}

}

}

}

package test.MyThread.ticketDemo;

public class ticketDemo1 {

public static void main(String[] args) {

//这里没有改动，只是在上一个代码中加了一把锁

RunnableThread r1 = new RunnableThread();

Thread t1 = new Thread(r1,“窗口一”);

Thread t2 = new Thread(r1,“窗口二”);

Thread t3 = new Thread(r1,“窗口三”);

t1.start();

t2.start();

t3.start();

}

}

可以看出来结果符合我们的预期，是正确的

现在又有了新的问题，那就是如果我在构造线程的RunnableThread类里面加入方法呢？同步代码块里面出现方法时，我们应该怎么“上锁”呢？

同步方法（this锁）

同步方法，在public的后面加上synchronized关键字

package test.MyThread.ticketDemo;

public class RunnableThread1 implements Runnable{

private int ticket = 100;

Object obj = new Object();

public boolean flag = true;

@Override

public void run(){

if(flag==true){

while(ticket>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

SellTicket1();

}

}

}

//同步方法，在public的后面加上synchronized关键字

public synchronized void SellTicket1(){

if(ticket>0){

System.out.println(Thread.currentThread().getName()+“正在出售第 “+ticket+” 张票”);

ticket–;

}

}

}

package test.MyThread.ticketDemo;

public class ticketDemo2 {

public static void main(String[] args) throws InterruptedException {

RunnableThread1 r = new RunnableThread1();

Thread t1 = new Thread(r,“窗口一”);

Thread t2 = new Thread(r,“窗口二”);

t1.start();

t2.start();

}

}

this锁

先来看看，如果有两条路径，一条路径是使用同步代码块，但是对象是obj，另一条路径是使用同步方法

package test.MyThread.ticketDemo;

public class TicketWindow2 implements Runnable{

//定义100张票

private static int tickets = 100;

Object obj = new Object();

int i =0;

@Override

public void run() {

while (true){

if(i%2==0){

synchronized (obj){

if(tickets>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");

}

}

}else {

sellTicket();

}

i++;

}

}

public synchronized void sellTicket(){

if(tickets>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");

}

}

}

结果出错，说明同步方法的用的对象锁不能是任意的对象，不同的线程应该用相同的锁。同步方法是属于对象，而在这个类里面调用方法的是this对象，也就是this.sellTicket()，因此把this提取出来作为对象锁中的对象。这样多个线程都用的是this锁

package test.MyThread.ticketDemo;

public class TicketWindow2 implements Runnable{

//定义100张票

private static int tickets = 100;

Object obj = new Object();

int i =0;

@Override

public void run() {

while (true){

if(i%2==0){

synchronized (this){

if(tickets>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");

}

}

}else {

sellTicket();

}

i++;

}

}

public synchronized void sellTicket(){

if(tickets>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");

}

}

}

修改完成后再运行代码，发现没有错误

注：

1. 一个线程使用同步方法，另一个线程使用同步代码块this锁，可以实现同步

2. 一个线程使用同步方法，另一个线程使用同步代码块，但是不是this锁。这种情况不能实现同步。

静态同步方法

同步方法的锁对象是this，

静态同步方法的锁对象是：这个静态同步方法所属的类的字节码文件

下面代码挺长的，但其实就修改了上面同步方法的代码的两处地方

1. public synchronized void sellTicket(){}改为

public synchronized static void sellTicket(){}

2. synchronized (this){}改为synchronized (TicketWindow2.class){}

package test.MyThread.ticketDemo;

public class TicketWindow2 implements Runnable{

//定义100张票

private static int tickets = 100;

Object obj = new Object();

int i =0;

@Override

public void run() {

while (true){

if(i%2==0){

synchronized (TicketWindow2.class){

if(tickets>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");

}

}

}else {

sellTicket();

}

i++;

}

}

public synchronized static void sellTicket(){

if(tickets>0){

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");

}

}

}

main()方法里面创建进程和启动进程的代码，和上面同步方法里面的代码相同

结果也和上面的一样，都不再列出来了

死锁问题

package test.MyThread.ticketDemo;

//两个不同的锁对象

public class LockObject {

public static final Object lock1 = new Object();

public static final Object lock2 = new Object();

}

package test.MyThread.ticketDemo;

public class DieLockThread extends Thread{

public boolean flag;

public DieLockThread(boolean flag){

this.flag = flag;

}

@Override

public void run() {

if(flag){

synchronized(LockObject.lock1){

System.out.println(“lock1”);

synchronized(LockObject.lock2){

System.out.println(“lock2”);

}

}

}else{

synchronized(LockObject.lock2){

System.out.println(“lock2”);

synchronized(LockObject.lock1){

System.out.println(“lock1”);

}

}

}

}

}

package test.MyThread.ticketDemo;

public class DieLockDemo {

public static void main(String[] args) {

DieLockThread d1 = new DieLockThread(true);

DieLockThread d2 = new DieLockThread(false);

d1.start();

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

需要体系化学习资料的朋友，可以加我V获取：vip204888 （备注网络安全）

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习 网络安全的小伙伴们一点帮助！

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

😝朋友们如果有需要的话，可以联系领取~

1️⃣零基础入门

① 学习路线

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

② 路线对应学习视频

同时每个成长路线对应的板块都有配套的视频提供：

2️⃣视频配套工具&国内外网安书籍、文档

① 工具

② 视频

③ 书籍

资源较为敏感，未展示全面，需要的最下面获取

② 简历模板

因篇幅有限，资料较为敏感仅展示部分资料，添加上方即可获取👆

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！