本文讨论了Java中线程不安全的问题及其可能导致的错误。为了解决这一问题，文章介绍了synchronized方法和代码块，阐述了它们如何确保线程安全。尽管使用synchronized会带来性能影响和潜在的线程调度问题，但它通过锁机制保证了共享资源的正确访问。文中还给出了同步代码块的示例，并强调锁应该作用于会改变的变量以确保线程安全。
线程不安全的问题
在不做线程安全的情况下，多个线程访问一个资源会出现线程不安全的情况，容易出现不同的线程访问不同一个资源的情况。比如下列简单2个demo运行的效果，运行就会发现，会出现重复或者本身就已经按照逻辑已经不符合条件的，会出现不应该出现的结果。
//两个去银行，线程不安全的情况下
public class UnsafeBank {
public static void main(String[] args) {
//账号
Account account = new Account(new BigDecimal("100"), "结婚基金");
Drawing you = new Drawing(account,new BigDecimal("50"),"自己");
Drawing girlFriend = new Drawing(account,new BigDecimal("100"),"女朋友");
you.start();
girlFriend.start();
}
}
//银行账号
class Account{
//余额
BigDecimal momey;
//卡名
String name;
public Account(BigDecimal momey, String name) {
this.momey = momey;
this.name = name;
}
}
//银行：模拟取款
class Drawing extends Thread{
//账户
Account account;
//取多少钱
BigDecimal drawingMoney;
//现在还有多少钱
BigDecimal nowMoney;
public Drawing(Account account, BigDecimal drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public void run(){
int result = account.momey.subtract(drawingMoney).compareTo(new BigDecimal("0"));
if( result == -1) {
System.out.println("钱不够了");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 取出的钱
account.momey = account.momey.subtract(drawingMoney);
System.out.println(Thread.currentThread().getName()+"取钱的时候"+account.name+"余额为：" + account.momey);
System.out.println(Thread.currentThread().getName()+"取了钱" + drawingMoney);
}
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"小李").start();
new Thread(station,"王五").start();
new Thread(station,"李四").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean floag = true;
@Override
public void run() {
//买票
while (floag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
if(this.ticketNums <= 0) {
floag = false;
return;
}
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName() +"拿到了第"+ this.ticketNums--);
}
}
解决线程安全问题
针对线程问题，Java有2个解决方案，一个是synchronized方法和synchronized块。
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象锁才执行，否则线程会阻塞，方法一旦执行，就会独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才可以获得这个锁才可以继续执行。
有个缺点是，如果该方法是比较大的方法，会一定程度上运行效率。
由于同一个经常的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问的冲突问题。为了保证数据在方法中被访问时的准确性。在访问时加入锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待使用后是否锁即可。既然是这样，就会到来以下问题：
- 一个线程持有锁会导致其他需要此锁的线程挂起
- 在多线程竞争下，加锁释放锁会导致比较多的上下文切换和调度延时引起性能问题
- 吐过一个优先级高的线程等待一个优先级低级的线程锁释放锁，会导致优先级倒置，引起性能问题。
代码演示：购票加上锁后，就不会出现同一张票卖给不同的人
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"小李").start();
new Thread(station,"王五").start();
new Thread(station,"李四").start();
}
}
class BuyTicket implements Runnable{
//票
private int ticketNums = 10;
boolean floag = true;
@Override
public void run() {
//买票
while (floag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//synchronized 同步方法，锁的是this
private synchronized void buy() throws InterruptedException {
if(this.ticketNums <= 0) {
floag = false;
return;
}
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName() +"拿到了第"+ this.ticketNums--);
}
}
class Drawing extends Thread{
Account account; //账户
//取多少钱
BigDecimal drawingMoney;
//现在还有多少钱
BigDecimal nowMoney;
public Drawing(Account account, BigDecimal drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//运行后发现，并没有锁住账号的值支出变化。
@Override
public synchronized void run(){
int result = account.momey.subtract(drawingMoney).compareTo(new BigDecimal("0"));
if( result == -1) {
System.out.println("钱不够了");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 取出的钱
account.momey = account.momey.subtract(drawingMoney);
System.out.println(Thread.currentThread().getName()+"取钱的时候"+account.name+"余额为：" + account.momey.toString());
System.out.println(Thread.currentThread().getName()+"取了钱" + drawingMoney);
}
}
锁正在的做法是
//两个去银行，线程不安全的情况下
public class UnsafeBank {
public static void main(String[] args) {
//账号
Account account = new Account(new BigDecimal("100"), "结婚基金");
Drawing you = new Drawing(account,new BigDecimal("50"),"自己");
Drawing girlFriend = new Drawing(account,new BigDecimal("100"),"女朋友");
you.start();
girlFriend.start();
}
}
//银行账号
class Account{
//余额
BigDecimal momey;
//卡名
String name;
public Account(BigDecimal momey, String name) {
this.momey = momey;
this.name = name;
}
}
//银行：模拟取款
class Drawing extends Thread{
Account account; //账户
//取多少钱
BigDecimal drawingMoney;
//现在还有多少钱
BigDecimal nowMoney;
public Drawing(Account account, BigDecimal drawingMoney,String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
@Override
public synchronized void run(){
//这样的操作方式，才是线程安全的
synchronized (account) {
int result = account.momey.subtract(drawingMoney).compareTo(new BigDecimal("0"));
if( result == -1) {
System.out.println("钱不够了");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额 = 余额 - 取出的钱
account.momey = account.momey.subtract(drawingMoney);
System.out.println(Thread.currentThread().getName()+"取钱的时候"+account.name+"余额为：" + account.momey.toString());
System.out.println(Thread.currentThread().getName()+"取了钱" + drawingMoney);
}
}
}
同步快：synchronized（Object）{ }
Obj 称之为同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
同步监视器的执行过程：
- 第一个线程访问，锁定同步监视器，执行其中代码
- 第二个线程访问，发现同步监视器被锁定，无法访问
- 第一个线程访问完毕，解锁同步监视器
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
总结：所以实际锁机制，锁住的是需要变化的量，这样才可以保证线程安全。
扫一扫
1350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
