线程3：线程同步

为何要使用同步

安全问题银行取钱问题

三种同步方法
线程安全方法1同步代码块

方法2用同步方法实现

方法3同步锁Lock

为何要使用同步？

java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查），将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用，从而保证了该变量的唯一性和准确性。

安全问题—银行取钱问题

public class SynDemo {

//1.账户类
//这里关于内部类，用static修饰，可以直接new
//否则，要先获得外部类的实例才能new（类似：new Outter().new Inner()）
public static class Account{
private int balance;        //账户本来有多少钱，在构造器中写出
public Account(){}
public Account(int balance){
this.balance=balance;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}

//2.取钱类（线程类）
static class DrawThread extends Thread {
//取钱时需要账户和取多少
private Account account;
private int drawmoney;
public DrawThread(){}
public DrawThread(Account account,int drawmoney){
this.account=account;
this.drawmoney=drawmoney;
}
public Account getAcount() {
return account;
}
public void setAcount(Account account) {
this.account = account;
}
public int getDrawmoney() {
return drawmoney;
}
public void setDrawmoney(int drawmoney) {
this.drawmoney = drawmoney;
}
//run方法
/*
public void run(){
if(account.getBalance()>=drawmoney){//余额足
System.out.println("取钱成功，吐出钞票："+ drawmoney);  //先出钞票
account.setBalance(account.getBalance()-drawmoney);//然后才在余额减
System.out.println("余额："+account.getBalance());
}else{
System.out.println("取钱失败，余额不足！");
}
}
*/
public void run(){
if(account.getBalance()>=drawmoney){//余额足
System.out.println("取钱成功，吐出钞票："+ drawmoney);
try {
Thread.sleep(1);           //在出钱和减钱之间sleep，会让线程2进来
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
account.setBalance(account.getBalance()-drawmoney);
System.out.println("余额："+account.getBalance());
}else{
System.out.println("取钱失败，余额不足！");
}
}
}
//3.main测试
public static void main(String[] args) {
//简历两个取钱线程
Account ac =new Account(1000);   //
new DrawThread(ac,800).start();;
new DrawThread(ac,800).start();;
}
}

注释前的run出错的可能性小，run中加sleep后会出错。



未加同步时，余额为负，出错。以下介绍三种不同方法。

三种同步方法

线程安全方法1：（同步代码块）

/*
*   1.同步代码块：synchronized(obj){
*               }
*     obj为监视器，允许为任何对象，但建议以可能并发访问的资源做监视器
* */

public void run(){
synchronized(account){
if(account.getBalance()>=drawmoney){//余额足
System.out.println("取钱成功，吐出钞票："+ drawmoney);
try {
Thread.sleep(1); //在出钱和减钱之间sleep，会让线程2进来。但有同步
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
account.setBalance(account.getBalance()-drawmoney);
System.out.println("余额："+account.getBalance());
}else{
System.out.println("取钱失败，余额不足！");
}
}
}

说明：同步监视器对account锁定，其他线程无法获得锁。符合“加锁—修改—释放锁”的逻辑

方法2：用同步方法实现

（synchronized只可以修饰方法或代码块，不能修饰构造器、成员变量）

修饰普通方法，run中调用即可

在Account类中写draw方法。修饰方法或变量均可。

public synchronized void draw(int money) {
account -= money;
}

/**
* 用同步代码块实现
*
*/
public void draw1(int money) {
synchronized (this) {
account -= money;
}
}

方法3：同步锁（Lock）

java.util.concurrent.locks.ReentrantLock

同样对普通方法

public void m(){
lock.lock();
try{

}finally{
lock.unlock();
}
}

public  class Account{   //这里关于内部类，用static修饰，可以直接new
private int balance;            //账户本来有多少钱，在构造器中写出
public Account(){}
public Account(int balance){
this.balance=balance;
}

//在账户中写draw()方法
//定义锁对象
private final ReentrantLock lock = new ReentrantLock();

public void draw(int drawmony) {
//1.step1.加锁
lock.lock();
try{
if(balance >= drawmony){//余额足
System.out.println("取钱成功，吐出钞票："+ drawmony);
try {
Thread.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
balance-=drawmony;
System.out.println("余额："+balance);
}else{
System.out.println("取钱失败，余额不足！");
}
}finally{
lock.unlock();
}
}
}

线程类中调用

public void run(){
//java.util.concurrent.locks.ReentrantLock
account.draw(drawmoney);
}