黑马程序员——第12天——多线程（2/2）

最新推荐文章于 2015-09-01 20:20:18 发布

Awizard23

最新推荐文章于 2015-09-01 20:20:18 发布

阅读量317

点赞数

分类专栏：黑马程序员文章标签：黑马程序员多线程

本文链接：https://blog.csdn.net/lgl092389/article/details/42493447

版权

黑马程序员专栏收录该内容

19 篇文章 0 订阅

订阅专栏

线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。

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{wait();}catch(Exception e){}
				if(x==0)
				{
				<span style="white-space:pre">	</span>r.name="mike";
			<span style="white-space:pre">	</span>	r.sex="man";
				}
				else
				{
				<span style="white-space:pre">	</span>r.name="丽丽"；
				<span style="white-space:pre">	</span>r.sex="女女女"；
				}
				x = (x+1)%2;
			<span style="white-space:pre">	</span>r.flag = true;
			<span style="white-space:pre">	</span>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{wait();}catch(Exception e){}
				System.out.println(r.name+"..."+r.sex);
				r.flag = false;
				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()；唤醒所有

/*
wati;
notify();
notifyAll();

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

为什么这些操作线程的方法要定义在Object类中呢？
因为这些方法在操作同步中线程时，都必须要标他们所操作线程持有的锁
只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒。
不可以对不同锁中的线程进行唤醒。

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

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

优化一下以上程序

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 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();
*/		
	}
}

生产者消费者

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


		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();
	}
}
/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。


为什么定义notifyAll
因为需要唤醒对方线程。
因为只用notify容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

*/
class Resource
{
	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;
		this.notifyAll();
	}
	public synchronized void out()
	{
		while(!flag)
			try{wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()"...消费者..."+this.name);
		flag = false;
		this.notifyAll();
	}
}

class Producer implements Runnable
{
	private Resource res;


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

class Cunsumer implements Runnable
{
	private Resource res;


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

JDK5.0升级版

import java.util.concurrent.locks.*;


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


		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();
	}
}
/*
<strong>JDK1.5中提供了多线程升级解决方案。（显示的锁机制以及显示的锁对象上的等待唤醒操作机制。一个锁可以有多组condition对象。）
将同步Synchronized替换成现实Lock操作。
将Object中的wait,notify,notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。</strong>

*/

class Resource
{
	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();//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();
		}
	}
}

class Producer implements Runnable
{
	private Resource res;


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

class Cunsumer implements Runnable
{
	private Resource res;

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

stop方法已经过时。

如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。

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

特殊情况：
当线程出于冻结状态。
就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结状态进行清除。
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

Thread类提供了该方法：Interrupt()；(sleep,wait,join都能唤醒)

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");
			}
			System.out.println(Thread.currentThread().getName()+"...run");
		}
	}
	public void changeFleg()
	{
		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.setDaemon(true);//<strong>守护线程</strong>
		t2.setDaemon(true);
		t1.start();
		t2.start();

		int num = 0;

		while(true)
		{
			if(num++ ==60);
			{
				//st.changeFlag();
<span style="white-space:pre">				</span>//t1.interrupt();
<span style="white-space:pre">				</span>//t2.interrupt();<span style="white-space:pre">	</span>				break;
			}
		System.out.println(Thread.currentThread().getName()+"....."+num);
		}
		System.out.println("over");
	}
}

join:
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程执行完，A才会执行。

join可以用来临时加入线程执行。

class Demo implements Runnable
{
	public void run()
	{
		for(int x = 0; x<70; x++)
		{
			System.out.println(Thread.currentThread().getName()+"..."+x);
		}
	}
}

class JoinDemo 
{
	public static void main(String[] args) throws Exception 
	{
		Demo d = new Demo();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		t1.start();

		t1.join();//t1抢夺CPU执行权

		t2.start();

		for (int x = 0; x<80 ; x++ )
		{
			System.out.println("main....."+x);
		}
		System.out.println("over");
	}
}

线程的优先级，时停止yield()

class Demo implements Runnable
{
	public void run()
	{
		for(int x = 0; x<70; x++)
		{
			System.out.println(Thread.currentThread().getName()+"..."+x);
			Thread.yield();//稍微减缓线程运行，暂时停止。
		}
	}
}

class JoinDemo 
{
	public static void main(String[] args) throws Exception 
	{
		Demo d = new Demo();
		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		t1.start();

		t1.setPriority(Thread.MAX_PRIORITY);//设置优先级，默认值为5，范围1-10。MAX，MIN,NORM

		//t1.join();

		t2.start();

		for (int x = 0; x<80 ; x++ )
		{
			System.out.println("main....."+x);
		}
		System.out.println("over");
	}
}

技巧写法，用匿名内部类

class ThreadTest 
{
	public static void main(String[] args) 
	{

		new Thread()
		{
			public void run()
			{
				for(int x=0; x<100; x++)
				{
					System.out.println(Thread.currentThread().getName()+"....."+x);
				}
			}
		}.start();

		for(int x=0; x<100; x++)
		{
			System.out.println(Thread.currentThread().getName()+"...."+x);
		}
		
		Runnable r = new Runnable()
		{
			public void run()
			{
				for(int x=0; x<100; x++)
				{
					System.out.println(Thread.currentThread().getName()+"...."+x);
				}	
			}
		};
		new Thread(r).start();		
		
		//new Test1().start();
	}
}
		
		
/*		
class Test1 extends Thread
{
	public void run()
	{
		for(int x=0; x<100;x++)
		{
			System.out.println(Thread.currentThread().getName()+"...."+x);
		}
	}
}
*/

Awizard23

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——第12天——多线程（2/2）

/*线程间通讯：其实就是多个线程在操作同一个资源，但是操作的动作不同。*/class Res{ String name; String sex; boolean flag = false//默认值即为假。}class Input implements Runnable{ private Res r; Input(Res r) { this.r
复制链接

扫一扫