线程同步

 

一、线程同步的概念

        处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。 这时候，我们就需要用到“线程同步”。 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。

【示例】多线程操作同一个对象(未使用线程同步)

import javax.management.DescriptorAccess;

public class TestUnsafe {
    public static void main(String[] args) {
        Account account = new Account("张三", 100);
        Drawing drawing = new Drawing(account, 80);
        Drawing drawing2 = new Drawing(account, 90);
        drawing.start();
        drawing2.start();

    }

}
class  Drawing extends Thread{
    int drawMoney;
    Account account;
    int allMoney;
    public Drawing(Account accounbt,int drawMoney){
        this.account=accounbt;
        this.drawMoney=drawMoney;
    }
    public void run(){
        if(account.money-allMoney<0){
            return;
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.money-=drawMoney;
        allMoney+=drawMoney;
        System.out.println(Thread.currentThread().getName()+"-->账户余额："+account.money);
        System.out.println(Thread.currentThread().getName()+"-->总共取了"+allMoney);
    }
}

【运行结果】

 

二、实现线程同步 

       由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问造成的这种问题。

      由于我们可以通过 private 关键字来保证数据对象只能被方法访问，所以我们只需针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized 方法和 synchronized 块。

▪ synchronized 方法

      通过在方法声明中加入 synchronized关键字来声明，语法如下：

public  synchronized  void accessVal(int newVal);

        synchronized 方法控制对“对象的类成员变量”的访问：每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。

▪ synchronized块

      synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率。

      Java 为我们提供了更好的解决办法，那就是 synchronized 块。 块可以让我们精确地控制到具体的“成员变量”，缩小同步的范围，提高效率。

      synchronized 块：通过 synchronized关键字来声明synchronized 块，语法如下：

synchronized(syncObject)
　  { 
　　 //允许访问控制的代码 
　  }

【示例】 多线程操作同一个对象(使用线程同步)

public class TestSafe {
    public static void main(String[] args) {
        Account account = new Account("张三", 100);
        Drawing1 drawing = new Drawing1(account, 80);
        Drawing1 drawing2 = new Drawing1(account, 90);
        drawing.start();
        drawing2.start();

    }

}

class Drawing1 extends Thread{
    int drawingNum;
    Account account;
    int expenseTotal;
    public Drawing1(Account accounbt,int drawingNum){
        super();
        this.account=accounbt;
        this.drawingNum=drawingNum;
    }
    public void run(){
        draw();
    }
    void draw() {
        synchronized (account) {
            if (account.money - drawingNum < 0) {
                System.out.println(this.getName() + "取款，余额不足！");
                return;
            }
            try {
                Thread.sleep(1000); // 判断完后阻塞。其他线程开始运行。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            account.money -= drawingNum;
            expenseTotal += drawingNum;
        }
        System.out.println(this.getName() + "--账户余额：" + account.money);
        System.out.println(this.getName() + "--总共取了：" + expenseTotal);
    }
}

【运行结果】