黑马程序员-面向对象：多线程(2)

最新推荐文章于 2024-09-13 21:40:38 发布

kensib

最新推荐文章于 2024-09-13 21:40:38 发布

阅读量81

点赞数

文章标签： java 移动开发运维

本文链接：https://blog.csdn.net/kensib/article/details/84391658

版权

　------- android培训、java培训、期待与您交流！ ----------

01 线程间通信-代码示例

02 解决安全问题

需求：解决线程间通信问题

步骤：

1。先建立一个双线程程序

这个双线程操作的是同一个资源但是操作动作不同，也就是需要建立三个类：资源，输入，输出

输入和输出类建立引入一个资源类的对象，而且这个对象是两个类共享的？？

2。线程间安全问题

需要同步的代码块是两个类中都有，一个输入动作，一个输出动作，因此两个类中的run方法都要同步

同步的对象需要唯一，可以考虑class文件，建议Res类的对象，因为这个对象是唯一的而且是两个类共享的

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

class Input implements Runnable
{
	private Res r;//??为什么要私有？？
	Input(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		int x = 0;
		while (true)
		{
			synchronized(r)
			{
				if (r.flag)
				{
					try
					{
						r.wait();
					}
					catch (Exception e)
					{

					}
				}
				//wait()是obj类中的方法，要抛出异常，只能try不能抛。为了避免同步嵌套，所以前面加对象引用，这个对象是锁
				if (x == 0)
				{
					r.name = "mike";
					r.sex = "man";
				}
				else
				{
					r.name = "莉莉";
					r.sex = "女";
				}
				x= (x+1) % 2;
				r.flag = true;
				r.notify();
			}
		}
	}
}

class Output implements Runnable
{
	private Res r;//??为什么要私有？？
	Output(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while (true)
		{
			synchronized(r)
			{
				if(!r.flag)
				{
					try
					{
						r.wait();
					}
					catch (Exception e)
					{

					}
				}
				System.out.println(r.name+"---"+r.sex);
				r.flag = false;
				r.notify();
			}
		}	
	}
}



class  InputOutputDemo
{
	public static void main(String[] args) 
	{
		Res r = new Res();
		Input in = new Input(r);
		Output out = new Output(r);

		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);

		t1.start();
		t2.start();
	}
}

//notifyAll();

wait;

notify();

notifyAll();

都使用在同步中，因为要对持有监视器（锁）的线程操作

所以要使用在同步中，因为只有同步才具有锁

为什么这些操作线程的方法要定义在Object类中呢？

因为锁是任意对象

等待和唤醒必须是同一把锁

12.04线程间通信-代码优化

同一对象的两个同步方法代码

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();
		/*Input in = new Input(r);
		Output out = new Output(r);

		Thread t1 = new Thread(in);
		Thread t2 = new Thread(out);

		t1.start();
		t2.start();*/
	}
}

12.05 线程间通信-生产消费者

class Resourse

{

private String name;

private int count = 1;

private boolean flag = false;

public synchronized void set(String name)

{

while(flag)

{try

{

wait();

}

catch (Exception e)

{

}

this.name = name+"----"+count++;

System.out.println(Thread.currentThread().getName()+"--生产者--"+this.name);

flag = true;

notifyAll();

}

public synchronized void out()

{

while(!flag)

{try

{

wait();

}

catch (Exception e)

{

}

System.out.println(Thread.currentThread().getName()+"--消费者--"+this.name);

flag = false;

notifyAll();

}

class Producer implements Runnable

{

private Resourse r;

Producer(Resourse r)

{

this.r = r;

}

public void run()

{

while(true)

{

r.set("商品");

}

class Consumer implements Runnable

{

private Resourse r;

Consumer(Resourse r)

{

this.r = r;

}

public void run()

{

while (true)

{

r.out();

}

class ProducerConsumerDemo

{

public static void main(String[] args)

{

Resourse res = new Resourse();

Producer pro = new Producer(res);

Consumer con = new Consumer(res);

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();

}

对于多个生产者和消费者

为什么要定义while判断标记

原因：

让被唤醒的线程再判断一次标记

为什么要定义notifiAll

因为要唤醒对方线程

如果只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待，

这样会导致程序锁住

12.06 生产者消费者JDK1.5 升级版 lock condition

import java.util.concurrent.locks.*;

class Resourse
{
	private String name;
	private int count = 1;
	private boolean flag = false;
	
	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();
			this.name = name+"----"+count++;
			System.out.println(Thread.currentThread().getName()+"--生产者--"+this.name);
			flag = true;
			condition_con.signal();	
		}
		finally
		{
			lock.unlock();
		}
	}
	
	public synchronized 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 Resourse r;
	Producer(Resourse r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				r.set("商品");
			}
			catch (InterruptedException e)
			{
			}
			
		}
	}
}

class Consumer implements Runnable
{
	private Resourse r;

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

class ProducerConsumerDemo2
{
	public static void main(String[] args)
	{
		Resourse res = new Resourse();
	
		Producer pro = new Producer(res);
		Consumer con = new Consumer(res);
	
		
		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();
	}  
}

JDK1.5中提供了多线程升级解决方案

将同步Synchronized替换成实现Lock操作

将Object中的wait，notify，notifyAll替换成了condition

对象，该对象可以对Lock锁进行获取

该示例中，实现了本方只唤醒对方操作

12.07 停止线程

stop方法已经过时

如何停止线程？

只有一种，run方法结束

开启多线程运行，运行代码通常都是循环结构

只要控制住线程，就可以让run方法结束，也就是线程结束

特殊情况：

当线程处于冻结状态，就不糊读取到标记，线程无法结束

当没有指定的方式让冻结的线程恢复到运行状态，这是需要对冻结进行清除

强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束

Thread类中提供了该方法interrupt（）

class StopThread implements Runnable
{
	private boolean flag = true;
	public synchronized void run()
	{
		while (flag)
		{
			try
			{
				wait();
			}
			catch (InterruptedException e)
			{
				System.out.println(Thread.currentThread().getName()+"--Exception");
				flag = false;
			}
			System.out.println(Thread.currentThread().getName()+"--run");
		}
	}
	public void changeFlag()
	{
		flag = false;
	}
}

class  StopThreadDemo
{
	public static void main(String[] args) 
	{
		StopThread st = new StopThread();

		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);

		t1.start();
		t2.start();

		int num = 0;

		while (true)
		{
			if (num++ == 60)
			{
				//st.changeFlag();
				t1.interrupt();
				t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"----"+num);
		}
	}
}

setDaemon(true)//相当于前台与后台，守护线程依赖于前台存在，前台退出后台也退出

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。

该方法必须在启动线程前调用。

该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。

参数：

on - 如果为 true，则将该线程标记为守护线程