线程的同步(Java内存模型)

线程的同步

保证多线程安全访问竞争资源的一种手段，避免多个线程同时修改一个资源，导致资源的不正确性。

相关概念：

• 什么是竞争资源
• 什么时候需要同步
• 要怎样进行同步

1. 将竞争资源标为private
2. 将涉及到静态资源的方法或块用synchrized关键字修饰

同步方法

模拟银行转账功能

package cn.domin.threadr.sync;
public class Thransfer {
        User u = new User();
        u.setBalance(10000);
        u.setCode(0x08);
        
        ATMThread a1 = new ATMThread("ATM1", u, 1000);
        ATMThread a2 = new ATMThread("ATM2", u, 5000);
        ATMThread a3 = new ATMThread("ATM3", u, 3000);
        a1.start();
        a2.start();
        a3.start();
    }
}
class ATMThread extends Thread{
    private User u;
    private int y;
    public ATMThread(String name,User u,int y) {
        super(name);
        this.u = u;
        this.y = y;
    }
    
    public void oper(int y) {
        int m = u.oper(y);
        System.out.println(Thread.currentThread().getName()+"操作"+y+"元，账户余额"+m+"元");
    }
    
    public void run() {
        oper(y);
    }
    
}

class User{
    private int code;
    private int balance;
    
    public synchronized int oper(int y) {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        balance += y;
        return balance;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }
}

volitile关键字

• 修饰的变量在同一时间只能由一个线程进行操作
• 需要注意的是，当变量的值和自身上一个值无关时，所做的操作才是原子级别的
• 原子操作，是指不会被线程调度打断的操作，该线程
• volatile属性操作并不能保证操作的原子性，可使用synchronized关键字、锁机制、同步类来保证操作的原子性。

public class Thransfer {
    
    private volatile int it;
    
    public static void main(String[] args) {
        User u = new User();
        u.setBalance(10000);
        u.setCode(0x08);
        
//      ATMThread a1 = new ATMThread("ATM1", u, 1000);
//      ATMThread a2 = new ATMThread("ATM2", u, 5000);
//      ATMThread a3 = new ATMThread("ATM3", u, 3000);
//      a1.start();
//      a2.start();
//      a3.start();
        final Thransfer t = new Thransfer();
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    t.cre();
                }
            }).start();
        }
        while(Thread.activeCount()>1) {
            Thread.yield();
        }
        System.out.println(t.it);
    }
    
    public synchronized void cre() {
        this.it++;
    }
}

概念知识
Java内存模型：

1. 可见性
   线程之间的修改状态是可见的。也就是说一个线程修改的结果，另一个线程是立马可见的。比如volitile关键字，其修饰的变量不允许线程缓存和重排序，所以对其他线程是可见的，要注意不可分割性。
2. 原子性
   原子是世界上最小的单位，具有不可分割性，那么我们称不可分割的操作为原子操作，n++和n=n+1都不属于原子操作，因为他是分割的。
3. 有序性
   java提供二种方式来保证xi线程操作之间的有序性
   
4. volitile本身具有禁止指令重拍的语义
5. synchronization关键字在同一时间只允许一个线程进行操作，属于串行操作，保证线程间的有序性。

参考链接