锁对象Lock-同步问题更完美的处理方式

时间 2019-11-08

标签对象 lock 同步问题完美处理方式繁體版

原文原文链接

Lock是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可得到的更普遍的锁定操做，它能以更优雅的方式处理线程同步问题，固然也能实现sychronized同样的效果，代码以下：java

package org.thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Output {

	private Lock lock = new ReentrantLock();

	public void output(String name) {
		
		try {
			lock.lock();
			for (int i = 0; i < name.length(); i++) {
				System.out.print(name.charAt(i));

			}

		} catch (Exception e) {

		} finally {
			lock.unlock();
		}

	}

}

如今看看并发

package org.thread;

public class Outputer {
	
	public synchronized void input(String name){
		
					for(int i =0;i<name.length();i++){
				System.out.print(name.charAt(i));
		}
		
	}

}

这两个方法其实都是为了实现数据同步dom

package org.thread;

public class LockTest {
	
	public static void main(String[] args) {
		final Outputer outputer = new Outputer();
		final Output output = new Output();
		Runnable runnable1 = new Runnable() {
			public void run() {
				
				outputer.input("Heinrich");
			}
		};
		
		Runnable runnable2 = new Runnable() {
			
			@Override
			public void run() {
				outputer.input("AmiLoveMe");
			}
		};
		
		Runnable runnable3 = new Runnable() {
			public void run() {
				
				output.output("Heinrich");
			}
		};
		
		Runnable runnable4 = new Runnable() {
			
			@Override
			public void run() {
				output.output("AmiLoveMe");
			}
		};
		
		new Thread(runnable2).start();
		new Thread(runnable1).start();
		new Thread(runnable3).start();
		new Thread(runnable4).start();
		
	}

}

看看控制台的信息是否是咱们想要的,结果确定是的,反正我以为是ide

AmiLoveMeHeinrichHeinrichAmiLoveMe  是我要的结果,有序,数据一致

这样就实现了和sychronized同样的同步效果，须要注意的是，用sychronized修饰的方法或者语句块在代码执行完以后锁自动释放，而是用Lock须要咱们手动释放锁，因此为了保证锁最终被释放(发生异常状况)，要把互斥区放在try内，释放锁放在finally内。性能

若是说这就是Lock，那么它不能成为同步问题更完美的处理方式，下面要介绍的是读写锁(ReadWriteLock)，咱们会有一种需求，在对数据进行读写的时候，为了保证数据的一致性和完整性，须要读和写是互斥的，写和写是互斥的，可是读和读是不须要互斥的，这样读和读不互斥性能更高些，来看一下不考虑互斥状况的代码原型：this

如今看代码:没有读写锁的spa

package org.thread;

public class Data {
	
	private Integer data;

	public void get() {
		System.out.println(Thread.currentThread().getName()+"准备读取数据");
		try {
			Thread.sleep(4000);
		} catch (Exception e) {
		}
		System.out.println(Thread.currentThread().getName()+"读取"+this.data);
	}

	public void set(Integer data) {
		System.out.println(Thread.currentThread().getName()+"准备写入数据");
		try {
			
			Thread.sleep(4000);
		} catch (Exception e) {
		}
		this.data = data;
		System.out.println(Thread.currentThread().getName()+"写入"+this.data);
	}
	
	


}

package org.thread;

import java.util.Random;

public class DataThread {

	public static void main(String[] args) {
		final Data data = new Data();
		for (int i = 0; i < 10; i++) {

			Runnable runnable1 = new Runnable() {

				@Override
				public void run() {
					data.set(new Random().nextInt(100));

				}
			};

			new Thread(runnable1).start();
		}
		
		for (int i = 0; i < 10; i++) {

			Runnable runnable2 = new Runnable() {

				@Override
				public void run() {
					data.get();

				}
			};
			
			new Thread(runnable2).start();
		}
		

		

	}

}

看看控制台线程

Thread-0准备写入数据
Thread-8准备写入数据
Thread-5准备写入数据
Thread-4准备写入数据
Thread-3准备写入数据
Thread-2准备写入数据
Thread-7准备写入数据
Thread-1准备写入数据
Thread-6准备写入数据
Thread-9准备写入数据
Thread-10准备读取数据
Thread-12准备读取数据
Thread-11准备读取数据
Thread-14准备读取数据
Thread-15准备读取数据
Thread-16准备读取数据
Thread-13准备读取数据
Thread-17准备读取数据
Thread-18准备读取数据
Thread-19准备读取数据
Thread-7写入28
Thread-3写入56
Thread-8写入83
Thread-2写入88
Thread-9写入83
Thread-5写入88
Thread-0写入84
Thread-6写入28
Thread-1写入28
Thread-4写入28
Thread-19读取56
Thread-12读取56
Thread-14读取56
Thread-13读取56
Thread-16读取56
Thread-10读取56
Thread-11读取56
Thread-15读取56
Thread-17读取56
Thread-18读取56

咱们要实现写入和写入互斥，读取和写入互斥，读取和读取互斥，在set和get方法加入code

synchronized修饰符接口

package org.thread;

public class Data {
	
	private Integer data;

	public synchronized void get() {
		System.out.println(Thread.currentThread().getName()+"准备读取数据");
		try {
			Thread.sleep(4000);
		} catch (Exception e) {
		}
		System.out.println(Thread.currentThread().getName()+"读取"+this.data);
	}

	public synchronized void set(Integer data) {
		System.out.println(Thread.currentThread().getName()+"准备写入数据");
		try {
			
			Thread.sleep(4000);
		} catch (Exception e) {
		}
		this.data = data;
		System.out.println(Thread.currentThread().getName()+"写入"+this.data);
	}
	
	


}

Thread-0准备写入数据
Thread-0写入54
Thread-19准备读取数据
Thread-19读取54
Thread-18准备读取数据
Thread-18读取54
Thread-17准备读取数据
Thread-17读取54
Thread-16准备读取数据
Thread-16读取54
Thread-15准备读取数据
Thread-15读取54
Thread-14准备读取数据
Thread-14读取54
Thread-13准备读取数据
Thread-13读取54
Thread-12准备读取数据
Thread-12读取54
Thread-11准备读取数据
Thread-11读取54
Thread-10准备读取数据
Thread-10读取54
Thread-9准备写入数据
Thread-9写入42
Thread-8准备写入数据
Thread-8写入86
Thread-1准备写入数据
Thread-1写入30
Thread-2准备写入数据
Thread-2写入3
Thread-4准备写入数据
Thread-4写入81
Thread-3准备写入数据
Thread-3写入72
Thread-5准备写入数据
Thread-5写入15
Thread-6准备写入数据
Thread-6写入16
Thread-7准备写入数据
Thread-7写入33

咱们发现，虽然写入和写入互斥了，读取和写入也互斥了，可是读取和读取之间也互斥了，不能并发执行，效率较低，用读写锁实现代码以下：

package org.thread;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class DataSyn {

	private Integer data;
	private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

	public void get() {
		System.out.println(Thread.currentThread().getName() + "准备读取数据");
		readWriteLock.readLock().lock();;
		try {
			Thread.sleep(2000);
			System.out.println(Thread.currentThread().getName() + "正在读取数据"
					+ this.data);
		} catch (Exception e) {
		} finally {
			readWriteLock.readLock().unlock();

		}

	}

	public void set(Integer data) {
		System.out.println(Thread.currentThread().getName() + "准备写入数据");
		readWriteLock.writeLock().lock();;
		try {
			this.data = data;
			System.out.println(Thread.currentThread().getName()+"正在写入"+data);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			readWriteLock.writeLock().unlock();
		}

	}

}

Thread-5准备写入数据
Thread-5正在写入85
Thread-1准备写入数据
Thread-1正在写入74
Thread-6准备写入数据
Thread-6正在写入28
Thread-0准备写入数据
Thread-0正在写入93
Thread-3准备写入数据
Thread-4准备写入数据
Thread-7准备写入数据
Thread-8准备写入数据
Thread-3正在写入75
Thread-2准备写入数据
Thread-2正在写入75
Thread-4正在写入70
Thread-7正在写入65
Thread-9准备写入数据
Thread-8正在写入92
Thread-9正在写入88

这个是否是效率更好了,固然咯,要否则说这么多干什么