✅作者简介：大家好我是@每天都要敲代码，希望一起努力，一起进步！
📃个人主页：@每天都要敲代码的个人主页🔥系列专栏：JavaSE从入门到精通
💬推荐一款模拟面试、刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习
目录
一：线程安全（很重要）
关于多线程并发环境下，数据的安全问题：
1、为什么这个线程安全是重点？
在以后在开发中，我们的项目都是运行在服务器当中，而服务器已经将线程的定义，线程对象的创建，启动等，都已经实现完了。这些代码我们都不需要编写。最重要的是：我们要知道，你编写的程序需要放到一个多线程的环境下运行，你更需要关注的是这些数据在多线程并发的环境下是否是安全的
我们举个生活中的简单例子：线程并发对同一个账户取款。我和小鹏同时去取款，我是把钱取出来，如果因为数据延迟，没有及时更新账户；此时小鹏再去取款也取出来了，这就会造成数据的不安全！
2、什么时候数据在多线程并发的环境下会存在安全问题？
条件1：多线程并发。
条件2：有共享数据。
条件3：共享数据有修改的行为。满足以上3个条件之后，就会存在线程安全问题。
3、怎么解决线程安全问题？线程同步机制
当多线程并发的环境下，有共享数据，并且这个数据还会被修改，此时就存在线程安全问题，怎么解决这个问题？
线程排队执行（不能并发）；用排队执行解决线程安全问题；这种机制被称为：线程同步机制。专业术语叫做：线程同步，实际上就是线程不能并发了，线程必须排队执行！
线程同步就是线程排队了，线程排队了就会牺牲一部分效率，数据安全第一位，只有数据安全了，我们才可以谈效率。
4、说到线程同步这块，涉及到这两个专业术语：异步编程模型：线程t1和线程t2，各自执行各自的，t1不管t2，t2不管t1，谁也不需要等谁，这种编程模型叫做：异步编程模型。其实就是：多线程并发（效率较高）
同步编程模型：线程t1和线程t2，在线程t1执行的时候，必须等待t2线程执行结束，或者说在t2线程执行的时候，必须等待t1线程执行结束，两个线程之间发生了等待关系，这就是同步编程模型。效率较低。线程排队执行。
总结： 异步就是并发； 同步就是排队！
1.模拟两个线程对同一个银行账户取款（不使用线程同步）
1、Account账户类
package com.bjpowernode.java.threadsafe;
// 银行账户
public class Account {
// 账号
private String actno;
// 余额
private double balance;
// 构造方法
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
// setter and getter
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 取款方法
public void withdraw(double money){
// 取款之前的余额
double before = this.getBalance();
// 取款之后的余额
double after = before - money;
// 更新余额之前，进行睡眠1秒肯定会出问题
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 更新余额
this.setBalance(after);
}
}
2、两个线程对同一个账户取款
package com.bjpowernode.java.threadsafe;
public class AccountThread extends Thread{
// 保证两个线程共享一个账户对象
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
public void run() {
// 假设取款5000
double money = 5000;
// 取款
// 多线程并发执行这个方法
act.withdraw(money);
System.out.println(Thread.currentThread().getName()+
"对账户"+act.getActno()+"取款成功，余额"+act.getBalance());
}
}
3、测试
package com.bjpowernode.java.threadsafe;
public class Test {
public static void main(String[] args) {
// 创建对象
Account act = new Account("act---1",10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 设置线程名字
t1.setName("t1");
t2.setName("t2");
// 启动线程
t1.start();
t2.start();
}
}
/*
t1对账户act---1取款成功，余额5000.0
t2对账户act---1取款成功，余额5000.0
*/
二：使用线程同步机制（synchronized）
1、线程同步机制的语法是：
synchronized("数据"){
// 线程同步代码块。
}synchronized后面小括号中传的这个“数据”是相当关键的；这个数据必须是多线程共享的数据；才能达到多线程排队！
2、()中写什么？
（1）要看你想让哪些线程同步；假设t1、t2、t3、t4、t5，有5个线程；你只希望t1 t2 t3排队，t4 t5不需要排队。怎么办？你一定要在()中写一个t1 t2 t3共享的对象。而这个对象对于t4 t5来说不是共享的。（2）这里的共享对象是：账户对象；账户对象是共享的，那么this就是账户对象吧！当然不一定是this，这里只要是多线程共享的那个对象就行
（3）在java语言中，任何一个对象都有“一把锁”，其实这把锁就是标记！
；100个对象，100把锁。1个对象1把锁。对于锁的理解：相当于我们去上厕所，把门锁上，别人进不来；等解决了，打开锁别人才能进来！3、以下代码的执行原理？
（1）假设t1和t2线程并发，开始执行以下代码的时候，肯定有一个先一个后。
（2）假设t1先执行了，遇到了synchronized，这个时候自动找“后面共享对象”的对象锁，找到之后，并占有这把锁，然后执行同步代码块中的程序，在程序执行过程中一直都是占有这把锁的。直到同步代码块代码结束，这把锁才会释放。
（3）假设t1已经占有这把锁，此时t2也遇到synchronized关键字，也会去占有后面共享对象的这把锁，结果这把锁被t1占有，t2只能在同步代码块外面等待t1的结束，直到t1把同步代码块执行结束了，t1会归还这把锁，此时t2终于等到这把锁，然后t2占有这把锁之后，进入同步代码块执行程序。这样就达到了线程排队执行。
注意：这个共享对象一定要选好了；这个共享对象一定是你需要排队执行的这些线程对象所共享的！
1.模拟两个线程对同一个银行账户取款（使用线程同步）
package com.bjpowernode.java.Threadsafe2;
// 使用线程同步，解决线程安全问题
// 银行账户
public class Account {
// 账号
private String actno;
// 余额
private double balance;
// 构造方法
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
// setter and getter
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 取款方法，t1和t2并发这个方法
// t1和t2是两个栈，两个栈操作堆中同一个对象
public void withdraw(double money){
// 以下这几行代码必须是线程排队的，不能并发。
// 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
// 线程同步机制，线程同步执行
// this就是指当前共享的对象Account账户
synchronized (this){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
}
/*
t1对账户act---1取款5000.0成功，余额5000.0
t2对账户act---1取款5000.0成功，余额0.0
*/
2.sychronized的理解
2.1 不写this写其它的一个共享的对象；这里写this和“abc”是没区别的！
package com.bjpowernode.java.threadsafe2;
/*
银行账户
使用线程同步机制，解决线程安全问题。
*/
public class Account {
// 账号
private String actno;
// 余额
private double balance; //实例变量。
//对象
Object obj = new Object(); // 实例变量。
//（Account对象是多线程共享的，Account对象中的实例变量obj也是共享的。）
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
//取款的方法
public void withdraw(double money){
//int i = 100;
//i = 101;
// 以下这几行代码必须是线程排队的，不能并发。
// 一个线程把这里的代码全部执行结束之后，另一个线程才能进来。
//Object obj2 = new Object();
synchronized (this){ // 只要是一个共享对象就行
//synchronized (obj) { // 实例变量，Account对象是共享的，它的实例对象也可以
//synchronized ("abc") { // "abc"在字符串常量池当中；写"abc"所有线程都会同步
//synchronized (null) { // 报错：空指针。
//synchronized (obj2) { // 局部变量。因为obj2不是共享对象；每次调用都会new
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
//}
}
}2.2 如果修改下面代码，就不同了；this表示t1和t2是线程同步的，和t3没有关系；如果写"abc"那就是t1,t2,t3都是线程同步的！
package com.bjpowernode.java.threadsafe2;
public class Test {
public static void main(String[] args) {
// 创建账户对象（只创建1个）
Account act = new Account("act-001", 10000);
// 创建两个线程
Thread t1 = new AccountThread(act);
Thread t2 = new AccountThread(act);
// 又new对象，创建一个线程
Account act2 = new Account("act-001", 10000);
Thread t3 = new AccountThread(act2);
// 设置name
t1.setName("t1");
t2.setName("t2");
// 启动线程取款
t1.start();
t2.start();
}
}
2.3 扩大同步范围，不能写this，只能写当前对象！
package com.bjpowernode.java.Threadsafe2;
public class AccountThread extends Thread{
// 保证两个线程共享一个账户对象
private Account act;
// 通过构造方法传递过来账户对象
public AccountThread(Account act) {
this.act = act;
}
public void run() {
// 假设取款5000
double money = 5000;
// 取款
// 多线程并发执行这个方法
synchronized(act){
// 共享对象是act，不能写this，this代表的是线程对象AccountThread，
// 但是线程对象我们new了两个，不是共享的，这里扩大了同步范围
act.withdraw(money); // 在这里加synchronized，扩大了同步范围
}
System.out.println(Thread.currentThread().getName()+"对"+"账户"+act.getActno()+"取款"+money+"成功，余额"+act.getBalance());
}
}
3.那些变量有线程安全问题
1、Java中有三大变量【重要的内容】
实例变量：在堆中
静态变量：在方法区
局部变量：在栈中
2、以上三大变量中：
（1）局部变量永远都不会存在线程安全问题！因为局部变量不共享。（一个线程一个栈）局部变量在栈中。所以局部变量永远都不会共享。
（2）实例变量在堆中，堆只有1个。
（3）静态变量在方法区中，方法区只有1个。3、堆和方法区都是多线程共享的，所以可能存在线程安全问题
局部变量+常量：不会有线程安全问题。
成员变量：可能会有线程安全问题。（实例变量+静态变量）
4.sychronized出现在实例方法上
1、在实例方法上可以使用synchronized吗？可以的。
（1）synchronized出现在实例方法上，一定锁的是this；没得挑。只能是this。不能是其他的对象了。 所以这种方式不灵活。（2）另外还有一个缺点：synchronized出现在实例方法上，表示整个方法体都需要同步，可能会无故扩大同步的范围，导致程序的执行效率降低。所以这种方式不常用。
public synchronized void withdraw(double money){}
（3）synchronized使用在实例方法上有什么优点：代码写的少了。节俭了。
（4）如果共享的对象就是this，并且需要同步的代码块是整个方法体，建议使用这种方式。
package com.bjpowernode.java.threadsafe3;
// 银行账户
public class Account {
// 账号
private String actno;
// 余额
private double balance;
// 构造方法
public Account() {
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
// setter and getter
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
// 取款的方法
public synchronized void withdraw(double money){
double before = this.getBalance();
double after = before - money;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.setBalance(after);
}
}
5.总结synchronized的三种写法：
第一种：同步代码块，比较灵活
synchronized(线程共享对象){
同步代码块;
}第二种：在实例方法上使用synchronized，表示共享对象一定是this，并且同步代码块是整个方法体。
public synchronized void withdraw(double money){}第三种：在静态方法上使用synchronized表示找类锁，类锁永远只有1把。
就算创建了100个对象，那类锁也只有一把！
对象锁：1个对象1把锁，100个对象100把锁！
类锁：100个对象，也可能只是1把类锁！
synchronized面试题1：
面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
答：不需要，doSome执行时候会把这把锁占着，但是doOther()方法没有synchronized，不需要占用锁，直接就能执行
package com.bjpowernode.java.exam;
public class Exam01 {
public static void main(String[] args) {
MyClass mc = new MyClass();
Thread t1 = new MyThread(mc);
Thread t2 = new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
try {
Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
// 线程
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc) {
this.mc = mc;
}
public void run() {
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals(("t2"))){
mc.doOther();
}
}
}
class MyClass {
// doSome方法有synchronized，锁的是当前对象MyClass
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
// doOther方法没有synchronized
public void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
/* 执行结果：
doSome begin
doOther begin
doOther over
doSome over
*/
synchronized面试题2：
面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
答：需要，doSome执行时候会把这把锁占着，doOther()方法里也有synchronized，也需要占用这把锁去执行，所以需要等待doSome执行结束
package com.bjpowernode.java.exam;
public class Exam01 {
public static void main(String[] args) {
MyClass mc = new MyClass();
Thread t1 = new MyThread(mc);
Thread t2 = new MyThread(mc);
t1.setName("t1");
t2.setName("t2");
t1.start();
try {
Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
// 线程
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc) {
this.mc = mc;
}
public void run() {
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals(("t2"))){
mc.doOther();
}
}
}
class MyClass {
// doSome方法有synchronized，锁的是当前对象MyClass
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
// doOther方法也有synchronized
public synchronized void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
/* 执行结果：
doSome begin
doSome over
doOther begin
doOther over
*/
synchronized面试题3：
面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
答：不需要，doSome方法锁的是mc1对象，doSome方法锁的是mc2对象，这里是两把锁
package com.bjpowernode.java.exam03;
public class Exam02 {
public static void main(String[] args) {
// 创建了两个对象
MyClass mc1 = new MyClass();
MyClass mc2 = new MyClass();
Thread t1 = new MyThread(mc1);
Thread t2 = new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
try {
Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
// 线程
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc) {
this.mc = mc;
}
public void run() {
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals(("t2"))){
mc.doOther();
}
}
}
class MyClass {
// doSome方法有synchronized，锁的是当前对象MyClass
public synchronized void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
// doOther方法也有synchronized
public synchronized void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
/* 执行结果：
doSome begin
doOther begin
doOther over
doSome over
*/
synchronized面试题4：
面试题：doOther方法执行的时候需要等待doSome方法的结束吗？
答：都改成静态方法，synchronized出现在静态方法上是找类锁；需要，因为静态方法是类锁，不管创建了几个对象，类锁只有1把！
package com.bjpowernode.java.exam04;
public class Exam02 {
public static void main(String[] args) {
MyClass mc1 = new MyClass();
MyClass mc2 = new MyClass();
Thread t1 = new MyThread(mc1);
Thread t2 = new MyThread(mc2);
t1.setName("t1");
t2.setName("t2");
t1.start();
try {
Thread.sleep(1000); //这个睡眠的作用：为了保证t1线程先执行
} catch (InterruptedException e) {
e.printStackTrace();
}
t2.start();
}
}
// 线程
class MyThread extends Thread{
private MyClass mc;
public MyThread(MyClass mc) {
this.mc = mc;
}
public void run() {
if(Thread.currentThread().getName().equals("t1")){
mc.doSome();
}
if(Thread.currentThread().getName().equals(("t2"))){
mc.doOther();
}
}
}
class MyClass {
// doSome方法有synchronized，锁的是当前对象MyClass
public synchronized static void doSome(){
System.out.println("doSome begin");
try {
Thread.sleep(1000 * 10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("doSome over");
}
// doOther方法也有synchronized
public synchronized static void doOther(){
System.out.println("doOther begin");
System.out.println("doOther over");
}
}
/* 执行结果：
doSome begin
doSome over
doOther begin
doOther over
*/
6.死锁概述
假设有两个线程，T1是从上往下执行，T2对象是从下往上执行；T1先锁了上面一个对象，T2先锁住了下面一个对象；这就造成T1锁下面对象锁不了，T2锁上面对象锁不了；这样代码都不会执行结束，也就不会释放锁；不会出现异常，也不会出现错误，程序一直僵持在那里！
package com.bjpowernode.java.deadlock;
// 要会写死锁代码
public class DeadLock {
public static void main(String[] args) {
Object o1 = new Object();
Object o2 = new Object();
Thread t1 = new MyThread1(o1,o2);
Thread t2 = new MyThread2(o1,o2);
t1.start();
t2.start();
}
}
class MyThread1 extends Thread{
Object o1;
Object o2;
public MyThread1(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
public void run() {
// 先锁o1，在锁o2
synchronized (o1){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2){
}
}
}
}
class MyThread2 extends Thread{
Object o1;
Object o2;
public MyThread2(Object o1, Object o2) {
this.o1 = o1;
this.o2 = o2;
}
public void run() {
// 先锁o2，在锁o1
synchronized (o2){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1){
}
}
}
}7.开发中怎么解决线程安全问题
（1）是一上来就选择线程同步吗？synchronized
不是，synchronized会让程序的执行效率降低，用户体验不好；系统的用户吞吐量降低。用户体验差。在不得已的情况下再选择线程同步机制。
（2）第一种情况：尽量使用局部变量代替“实例变量和静态变量”。（3）第二种情况：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。（一个线程对应1个对象，100个线程对应100个对象，对象不共享，就没有数据安全问题了）
（4）第三种情况：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了。线程同步机制。
结束语
今天的分享就到这里啦！
快快通过下方链接注册加入刷题大军吧！各种大厂面试真题在等你哦！
💬刷题神器，从基础到大厂面试题👉点击跳转刷题网站进行注册学习
