Synchronized锁2

引入锁机制

引入锁机制以解决线程安全问题：
        悲观锁:当存在多个线程操作共享数据时，需要保证同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再进行
        乐观锁:CAS compare and set  会出现ABA问题  有3个线程，余额为1000，这个线程取钱200最后执行，一个线程存钱200，一个线程又取钱200，还是会出现问题

synchronized原理

在添加synchronized关键字后就可以保证在一个时刻上只有一个线程在调用某个方法或者代码块，不会出现并发的情形，达到排队执行的效果。

在Java中synchronized可保证在同一个时刻，只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作)，同时还应该注意到synchronized另外一个重要的作用，synchronized可保证一个线程的变化（主要是共享数据的变化）被其他线程所看到（保证可见性，完全可以替代volatile功能），这点确实也是很重要的。

在JDK1.6之前一般不建议使用synchronized，因为相比较Lock接口而言，是重量级的

jdk6之前是重量级锁，JDK6开始优化锁的状态总共有四种，无锁状态（使用乐观锁CAS，没有synchronized）、偏向锁、轻量级锁和重量级锁。锁状态的改变是根据竞争激烈程度进行的，在几乎无竞争的条件下，会使用偏向锁，在轻度竞争的条件下，会由偏向锁升级为轻量级锁， 在重度竞争的情况下，会升级到重量级锁。 随着锁的竞争，锁可以从偏向锁升级到轻量级锁，再升级的重量级锁，但是锁的升级是单向的，也就是说只能从低到高升级，不会出现锁的降级

对象在内存中存储时可以分为对象头、实例数据和对齐字节三部分。对象头数据一般包含标识字mark word和类型指针klass point；实例数据就是具体对象的成员数据，一般按照4B为的单位进行数据存储；最后的对齐字节用于将对象存储的数据凑够8字节的整数倍。

       - Mark Word：默认存储对象的HashCode，分代年龄和锁标志位信息。这些信息都是与对象自身定义无关的数据，所以Mark Word被设计成一个非固定的数据结构以便在极小的空间内存存储尽量多的数据。它会根据对象的状态复用自己的存储空间，也就是说在运行期间Mark Word里存储的数据会随着锁标志位的变化而变化

      - Klass Point：对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。

      - synchronized用的锁是存在Java对象头里的，存在锁对象的对象头的Mark Word中
        synchronized用的锁存储在Java对象头里，任何对象都有一个monitor与之关联，monitorenter指令是在编译后插入到同步的开始位置，而monitorexit是插入到结束处和异常处

锁对比

锁	描述	优点	缺点	适用场景
偏向锁	线程在大多数情况下并不存在竞争条件，使用同步会消耗性能，而偏向锁是对锁的优化，可以消除同步，提升性能。当一个线程获得锁，会将对象头的锁标志位设为01，进入偏向模式。偏向锁可以在让一个线程一直持有锁，在其他线程需要竞争锁的时候，再释放锁	加锁和解锁不需要额外的消耗，和执行非同步方法相比仅存在纳秒级 的差距	如果线程间存在锁竞争，会 带来额外的锁撤销的消耗	适用于只有一个线程访问同步块的场景
轻量级锁	当线程A获得偏向锁后，线程B进入竞争状态，需要获得线程A持有的锁，那么线程A撤销偏向锁，进入无锁状态。线程A和线程B交替进入临界区，偏向锁无法满足，膨胀到轻量级锁，锁标志位设为00	竞争的线程不会阻塞，提高了程序的相应速度	如果始终得不到所竞争的线程，使用自旋会消耗CPU	追求相应速度，同步块执行速度非常块
重量级锁	当多线程交替进入临界区，轻量级锁hold得住。但如果多个线程同时进入临界区，hold不住了，膨胀到重量级锁	线程竞争不使用自旋，不会消耗CPU	线程阻塞，响应时间缓慢	追求吞吐量，同步块执行速度较慢

会同时被多个线程访问的资源，就是竞争资源（临界资源），也称为竞争条件。对于多线程
共享的资源(临界资源)必须进行同步，以避免一个线程的改动被另一个线程所覆盖

使用两个线程模拟银行存取款操作

import java.io.Serializable;

//定义账户类：id编号  balance余额
public class Account implements Serializable {  
	private static final long serialVersionUID = -3901634772907041158L;
//账户类
	private long id;
	private double balance;
	public synchronized void draw(double num) {
		double dd=balance;
		if(balance<num||num<0)
			throw new IllegalArgumentException("账户余额不足");
		this.balance=dd-num;
	}
	public synchronized void disp(double num) {
		double dd=balance;
		if(num<0)
			throw new IllegalArgumentException();
		this.balance=dd+num;
	}
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public Double getBalance() {
		return balance;
	}
	public void setBalance(Double balance) {
		this.balance = balance;
	}
}

public class DespRunnable implements Runnable {
	private Account account;
	private double amount;

	public DespRunnable(Account account, double amount) {
		super();
		this.account = account;
		this.amount = amount;
	}

	@Override
	public void run() {
		System.out.println("开始存钱......");
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		account.disp(amount);
	}
	
}

public class DrawThread extends Thread {
	private Account account;
	private double amount;

	public DrawThread(Account account, double amount) {
		super();
		this.account = account;
		this.amount = amount;
	}

	@Override
	public void run() {
		if (account.getBalance() > amount) {
			System.out.println("开始出钱......");
			try {
				Thread.sleep(300);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			account.draw(amount);
		}
	}
}

public class Test1 {
	public static void main(String[] args) {
		Account account=new Account();
		account.setBalance(10000.0);
		account.setId(1L);
		for(int i=0;i<4;i++) {
			if(i%2==0)
				new DrawThread(account, 900).start();
			else
				new Thread(new DespRunnable(account, 100)).start();
		}
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(account.getBalance());
	}
}