java线程安全和不安全_Java线程安全与不安全

线程安全与不安全的理解

最常说的例子，用户取钱：假设A和B同时去不同ATM上取同一张账户的1000块钱，如果是线程不安全，那么A和B同时取钱时，就可能出现俩人都取到1000块钱，那么这俩人就发财了，而如果线程安全呢，就只有一个人能取出来1000块钱，另外一个人再取就是余额不足。

代码实现

实现上述取钱的例子

创建一个账户类

// 银行账户类

public class Account {

// private final Lock lock=new ReentrantLock();

// 余额

private double money =1000;

public double getMoney() {

return money;

}

public Account() { }

// 取钱

/*

在实例方法上使用synchronized，锁的一定是this对象。

这种方式不灵活，另外表示整个方法都需要同步，可能会无故扩大同步的范围。

导致程序的效率降低。所以这种方式不常用。

synchronized使用在实例方法上有什么优点？

就是代码比较少，写一个synchronized关键字就行。

如果共享的对象就是this，并且需要同步的代码是整个方法体，建议在实例方法上

添加synchronized关键字修饰，因为需要同步的确实是整个方法体。

*/

// 也可以在实例方法上，加synchronized，这样就扩大了安全的范围，同样效率就变低了

// public synchronized void withdraw(int m) {

public void withdraw(int m) {

//lock.lock();

// 以下代码是需要线程排队的

//synchronized (this) { // 括号里的参数传一个对象，只要对象必须是线程所共享的就行，也可以不是this

// 模拟网络延迟

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.money = this.money - m;

//lock.unlock();

//}

}

}

上述的例子注释中有实现锁的三种方式，都可以实现线程安全，现在先不开启，后面对比一下开启与不开启的区别，就可以更能理解的看到线程安全与不安全了。

创建一个线程运行类，可以理解为不同的取钱点。

// 线程运行类

public class AccountThread implements Runnable {

// 线程共享一个账户

private Account account;

// 取钱的数目

private int money;

public AccountThread(Account account, int money) {

this.account = account;

this.money = money;

}

@Override

public void run() {

// 开始取钱

account.withdraw(money);

System.out.println(Thread.currentThread().getName() + "取钱" + money + "元成功，剩余" + account.getMoney() + "元。");

}

}

测试类

public class Test01 {

public static void main(String[] args) {

// 创建银行账户，里边初始有1000

Account account = new Account();

// 俩个地点取钱

AccountThread at1 = new AccountThread(account, 200);

AccountThread at2 = new AccountThread(account, 100);

Thread t1 = new Thread(at1);

Thread t2 = new Thread(at2);

// 设置name

t1.setName("t1");

t2.setName("t2");

// 启动线程，开始取钱

t1.start();

t2.start();

}

}

线程非安全下运行结果：

多运行几次，会出现时而取钱正确，时而取钱错误。

线程安全下运行结果：

开启账户类中的任意一种(有三种方式：分别是 同步代码块 、同步方法和锁机制(Lock))线程安全的方式，即可保证输出无误。