学习笔记 java多线程 信号量(Semaphore),死锁

   信号量可以用来限制访问公共资源。在访问公共资源之前,线程必须从信号量获取许可。在访问资源之后,这个线程必须将许可返回给信号量,

  《学习笔记 java多线程 信号量(Semaphore),死锁》

        为了创建信号量,必须使用可选的公平策略来确定许可的数量。任务通过调用信号量acquire() 方法来获得许可,可通过调用信号量的release()方法来释放许可。一旦获得许可,信号量中可用许可的数量减一。一旦许可呗释放掉,信号量的可用许可的总数加1。

     《学习笔记 java多线程 信号量(Semaphore),死锁》

        使用只有一个许可的信号量可以模拟一个相互排斥的锁。

 

import java.util.concurrent.*;
public class SemaphoreTest
{
	private static  Account _account = new Account();

	public static void main(String[] args) 
	{
       ExecutorService executor = Executors.newCachedThreadPool();
	   for(int i=0; i<100;i++)
		{
			executor.execute(new depositTask());
		}
	    executor.shutdown();
        while(!executor.isTerminated())
		{
		}
		System.out.println("任务完成");
		System.exit(0);
	}

	private static class depositTask implements Runnable
	{
		@Override
		public  void run(){
			_account.deposit(1);	
			
		}
	}

	public static class Account
	{
		private static Semaphore _semaphore = new Semaphore(1,true);
		private int _menoeyy=0;

		private int GetMenoey(){
			return _menoeyy;
		}

		private void deposit(int monery)
		{
			
			try
			{
				_semaphore.acquire();
				_menoeyy+=monery;
				Thread.sleep(50);
				System.out.println(getAccountInfo());
			}
			catch ( InterruptedException ex)
			{
				
			} 
			finally
			{
                _semaphore.release();
			}
			
		}
        
		public  String getAccountInfo(){
			return "当前账户与额为:¥"+_menoeyy;
		}
	}
}

避免死锁

    有时两个或者多个线程需要在一个共享对象上获取锁,这可能导致死锁(Deadlock),也就是说,每个线程已经锁定一个对象,而且正在等待另一个对象。下面是一个很可能造成死锁的例子

  

import java.util.concurrent.*;
public class DeadlockTest 
{
	public static byte[] locker1 = new byte[0];
	public static byte[] locker2 = new byte[0];
	public static void main(String[] args) 
	{
		ExecutorService executor = Executors.newFixedThreadPool(100);
		for(int i =0 ;i <50;i++){
			executor.execute(new DeadlockTask1());
			executor.execute(new DeadlockTask2());
		}
		executor.shutdown();
		while(!executor.isTerminated()){
		
		}
		System.exit(0);
	}

	private static class DeadlockTask1 implements Runnable
	{
		public void run()
		{
			synchronized(locker1){
				System.out.println(" DeadlockTask1 获得锁 locker1 没有死锁!");
				synchronized(locker2){
					System.out.println(" DeadlockTask1 获得锁 locker2 没有死锁!");
				}
			}
		}
	}

	private static class DeadlockTask2 implements Runnable
	{
		public void run()
		{
			synchronized(locker2){
				System.out.println(" DeadlockTask2 获得锁 locker2 没有死锁!");
				synchronized(locker1){
					System.out.println(" DeadlockTask2 获得锁 locker1 没有死锁!");
				}
			}
		}
	}
}

《学习笔记 java多线程 信号量(Semaphore),死锁》

 

    但是使用资源排序技术就可以轻易的避免死锁的发生。原理就是为每一个需要锁的对象排序,确保每个线程都按照这个顺序来获取锁。假设,按照locker1、locker2的顺序对连个对象排序。采用资源排序技术,线程2必须先获得locker1上的锁,然后才能获取lock2上面的锁。一旦线程1 获取的locker1上的锁,线程2必须等待locker1的锁。所以不会在发生死锁现象。

 

import java.util.concurrent.*;
public class DeadlockTest 
{
	public static byte[] locker1 = new byte[0];
	public static byte[] locker2 = new byte[0];
	public static void main(String[] args) 
	{
		ExecutorService executor = Executors.newFixedThreadPool(100);
		for(int i =0 ;i <50;i++){
			executor.execute(new DeadlockTask1());
			executor.execute(new DeadlockTask2());
		}
		executor.shutdown();
		while(!executor.isTerminated()){
		
		}
		System.exit(0);
	}

	private static class DeadlockTask1 implements Runnable
	{
		public void run()
		{
			synchronized(locker1){
				System.out.println(" DeadlockTask1 获得锁 locker1 没有死锁!");
				synchronized(locker2){
					System.out.println(" DeadlockTask1 获得锁 locker2 没有死锁!");
				}
			}
		}
	}

	private static class DeadlockTask2 implements Runnable
	{
		public void run()
		{
			synchronized(locker1){
				System.out.println(" DeadlockTask2 获得锁 locker2 没有死锁!");
				synchronized(locker2){
					System.out.println(" DeadlockTask2 获得锁 locker1 没有死锁!");
				}
			}
		}
	}
}

 

 

       

作者:duanmengchao 发表于2012-5-5 13:05:46
原文链接 阅读:8 评论:0
查看评论

 

    原文作者:java锁
    原文地址: http://www.cnblogs.com/duanjie/archive/2012/05/05/2489177.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞