多线程——2

最新推荐文章于 2024-05-15 14:00:51 发布

meng_ft

最新推荐文章于 2024-05-15 14:00:51 发布

阅读量264

点赞数

本文链接：https://blog.csdn.net/hktkmft/article/details/25780423

版权

多线程之死锁

当同步中嵌套同步时而锁又不同时，就会产生死锁的现象。

一个死锁的例子

class Demo implements Runnable{
	private int inter=100;
	public  boolean falg=true;
	public void run()
	{
		
			if(falg)
			{
				while (true)
				{
					synchronized (Sisuo.class)
					{
						synchronized(Demo.class)
						{
							System.out.println(inter--);
						}
						
						
					}
				}
			}
			else
			{
				while (true)
				{
				synchronized (Demo.class)
				{
					synchronized(Sisuo.class)
					{
						System.out.println(Thread.currentThread() +""+inter--);
					}
					
					
				}
				}
			}
		
	}
	

}
class Sisuo
{
	public static void main(String[] args)
	{
		Demo s= new Demo();
		Thread t1= new Thread(s);
		Thread t2= new Thread(s);
		t1.start();
		try {Thread.sleep(10);
			
		} catch (Exception e) {
			// TODO: handle exception
		}
		s.falg=false;
		t2.start();
	}
	
	
	
	
}

线程间的通信

线程间通信的例子

class Res
{
	private String name;
	private String sex;
	private boolean flag = false;

	public synchronized void set(String name,String sex)
	{
		if(flag)
			try{this.wait();}catch(Exception e){}
		this.name = name;
		this.sex = sex;
		flag = true;
		this.notify();
	}
	public synchronized void out()
	{
		if(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(name+"........"+sex);
		flag = false;
		this.notify();
	}
}

class Input implements Runnable
{
	private Res r ;
	Input(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		int x = 0;
		while(true)
		{
			if(x==0)				
				r.set("mike","man");				
			else	
				r.set("丽丽","女女女女女");				
			x = (x+1)%2;
		}
	}
}

class Output implements Runnable
{
	private Res r ;
	
	Output(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}


class  InputOutputDemo2
{
	public static void main(String[] args) 
	{
		Res r = new Res();

		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
<span style="white-space:pre">	</span>｝
｝

等待唤醒机制

Wait、Notifig、NotifigAll，三个方法配合使用。这些方法定义在了Object中了，为什么会定义在Object中那？？

因为，

因为这些方法在操作同步中的线程时，都必须要标示它们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被同一个锁上的notifig唤醒。不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须使用同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

JDK1.5中提供了新的对象，优化了等待唤醒机制。

1.将synchronized替换成了Lock接口

2。将Object中的wait，notify，notifyAll方法替换成了，await，signal，signalAll

和以前不同是：一个同步代码块具备一个锁，该所以具备自己的独立wait和notify方法。
现在是将wait，notify等方法，封装进一个特有的对象Condition，而一个Lock锁上可以有多个Condition对象。

Lock例子

class ProducerConsumerDemo2 
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();

		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);

		Thread t1 = new Thread(pro);
		Thread t2 = new Thread(pro);
		Thread t3 = new Thread(con);
		Thread t4 = new Thread(con);

		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}
}


class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			//  t1    t2
	private Lock lock = new ReentrantLock();

	private Condition condition_pro = lock.newCondition();
	private Condition condition_con = lock.newCondition();



	public  void set(String name)throws InterruptedException
	{
		lock.lock();
		try
		{
			while(flag)
				condition_pro.await();//t1,t2
			this.name = name+"--"+count++;

			System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
			flag = true;
			condition_con.signal();
		}
		finally
		{
			lock.unlock();//释放锁的动作一定要执行。
		}
	}


	//  t3   t4  
	public  void out()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();
			System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
			flag = false;
			condition_pro.signal();
		}
		finally
		{
			lock.unlock();
		}
		
	}
}

class Producer implements Runnable
{
	private Resource res;

	Producer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.set("+商品+");
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;

	Consumer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.out();
			}
			catch (InterruptedException e)
			{
			}
		}
	}
}

wait和sleep的区别：
wait:释放cpu执行权，释放同步中锁。
sleep:释放cpu执行权，不释放同步中锁。

停止线程：
stop过时。
原理：run方法结束。run方法中通常定义循环，指定控制住循环线程即可结束。

1，定义结束标记。
2，当线程处于了冻结状态，没有执行标记，程序一样无法结束。
这时可以循环，正常退出冻结状态，或者强制结束冻结状态。
强制结束冻结状态：interrupt();目的是线程强制从冻结状态恢复到运行状态。
但是会发生InterruptedException异常。