JAVA锁机制

Java的原子性&&可见性&&有序性

    在讲锁之前，我们需要先知道什么是原子性，可见性和有序性。原子性，原子（atom）指化学反应不可再分的基本微粒，原子性的意思就是一个操作或者是一组操作在执行的过程中，要么都成功，要么都失败。可见性，是指一个变量，被一个线程修改了，那么其他线程能马上感知到修改的数据。有序性，是指程序执行的先后顺序，在Java的内存模型中，允许编译器和处理器对指令的重排序，重排序不会影响单线程的运行结果，当会影响多线程并发执行的正确性。

synchronized

    对非NULL的对象加锁，当作用于方法时，其实是对对象（object）加锁，多个线程访问时，只能运行一个线程访问synchronized加锁的方法，无论是不是同一个方法，当作用于静态方法时是对类（class）加锁，只允许一个线程执行同一类的静态方法，当作用于实例方法中的同步块时，同一时刻只允许一个线程对同步块里面的对象加锁，当作用于静态方法中的同步块时，同一时刻只允许一个线程对同步块里面的类加锁。

Look

    相对于synchronized基于JVM，Look属于程序控制，相比之下会更加灵活。一般使用ReentrantLock(重入锁)和ReentrantReadWriteLock(读写锁)这两种方式

类别	synchronized	Lock
存在层次	Java的关键字，在jvm层面上	是一个类
锁的释放	1、以获取锁的线程执行完同步代码，释放锁 2、线程执行发生异常，jvm会让线程释放锁	在finally中必须释放锁，不然容易造成线程死锁
锁的获取	假设A线程获得锁，B线程等待。如果A线程阻塞，B线程会一直等待	分情况而定，Lock有多个锁获取的方式，大致就是可以尝试获得锁，线程可以不用一直等待
锁状态	无法判断	可以判断
锁类型	可重入 不可中断 非公平	可重入 可判断 可公平（两者皆可）
性能	少量同步	大量同步

ReentrantLock

下面举一个例子：

import java.util.concurrent.locks.ReentrantLock;

public class TestLook{
	
	private int ticket = 1000;
	private ReentrantLock look = new ReentrantLock();
	
	public void get() {
		try {
			look.lock();
			System.out.println(Thread.currentThread().getName() + "加锁");
			ticket--;
			System.out.println("ticket:" + ticket);
		} finally {
			look.unlock();
			System.out.println(Thread.currentThread().getName() + "解锁");
		}
	}
	
	public static void main(String[] args) {
		TestLook look = new TestLook();
		TicketThread t = new TicketThread(look);
		for(int i = 0; i < 1000; i++) {
			Thread a = new Thread(t);
			a.start();
		}
	}
	
}

class TicketThread implements Runnable{

	private TestLook testLook;
	
	public TicketThread(TestLook testLook) {
		this.testLook = testLook;
	}
	
	@Override
	public void run() {
		testLook.get();
	}
	
}

ReentrantReadWriteLock

读写锁，可以减少锁的竞争，提高系统性能

读写锁的访问约束：

• 读-读不互斥：读读之间不阻塞
• 读-写互斥：读堵塞写，写也阻塞读
• 写-写互斥：写写阻塞

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class TestReentrantReadWriteLook {

	private int ticket = 1000;
	private ReentrantReadWriteLock look = new ReentrantReadWriteLock();
	private ReadLock readLook = look.readLock();
	private WriteLock writeLook = look.writeLock();
	
	
	public void get() {
		try {
			writeLook.lock();
			System.out.println(Thread.currentThread().getName() + "加锁");
			ticket--;
			System.out.println("get ticket:" + ticket);
		} finally {
			writeLook.unlock();
			System.out.println(Thread.currentThread().getName() + "解锁");
		}
	}
	
	public void query() {
		try {
			readLook.lock();
			System.out.println(Thread.currentThread().getName() + "加锁");
			System.out.println("query ticket:" + ticket);
		} finally {
			readLook.unlock();
			System.out.println(Thread.currentThread().getName() + "解锁");
		}
	}
	
	public static void main(String[] args) {
		TestReentrantReadWriteLook look = new TestReentrantReadWriteLook();
		TicketThread1 t1 = new TicketThread1(look);
		TicketThread2 t2 = new TicketThread2(look);
		for(int i = 0; i < 1000; i++) {
			Thread a1 = new Thread(t1);
			a1.start();
		}
		for(int i = 0; i < 1000; i++) {
			Thread a2 = new Thread(t2);
			a2.start();
		}
	}
	
}

class TicketThread1 implements Runnable{
	
	private TestReentrantReadWriteLook testLook;
	
	public TicketThread1(TestReentrantReadWriteLook testLook) {
		this.testLook = testLook;
	}
	
	@Override
	public void run() {
		testLook.get();
	}
	
}
class TicketThread2 implements Runnable{
	
	private TestReentrantReadWriteLook testLook;
	
	public TicketThread2(TestReentrantReadWriteLook look) {
		this.testLook = look;
	}
	
	@Override
	public void run() {
		testLook.query();
	}
	
}

 

转载于:https://my.oschina.net/u/2308196/blog/3016837