黑马程序员笔记——Java多线程线程间通讯

最新推荐文章于 2024-03-14 20:49:58 发布

黑马学习笔记

最新推荐文章于 2024-03-14 20:49:58 发布

阅读量314

点赞数

本文链接：https://blog.csdn.net/u014646324/article/details/26484903

版权

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

线程间通讯

概念

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

wait:
notify();
notifyAll();

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

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

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

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁，

只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。

不可以对不同锁中的线程进行唤醒。

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

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

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

代码优化后

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

生产者和消费者例子

class ProducerConsumerDemo 
{
	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();

	}
}

/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。


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

*/


class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;
			//  t1    t2
	public synchronized void set(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
		this.name = name+"--"+count++;

		System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
		flag = true;
		this.notifyAll();
	}


	//  t3   t4  
	public synchronized void out()
	{
		while(!flag)
			try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
		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 Consumer implements Runnable
{
	private Resource res;

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

JDK1.5升级解决方案

import java.util.concurrent.locks.*;


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


	}
}


/*
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。


Lock:替代了Synchronized
	lock 
	unlock
	newCondition()


Condition：替代了Object wait notify notifyAll
	await();
	signal();
	signalAll();
*/
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)
			{
			}
		}
	}
}

停止线程

如何停止线程？

stop方法已经过时。

只有一种，run方法结束。

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

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

特殊情况：

当线程处于了冻结状态。

就不会读取到标记。那么线程就不会结束。

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

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

Thread类提供该方法 interrupt();

class StopThread implements Runnable
{
	private boolean flag =true;
	public  void run()
	{
		while(flag)
		{
			
			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.setDaemon(true);
		t2.setDaemon(true);
		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);
		}
		System.out.println("over");
	}
}

守护线程

setDaemon(boolean on):将该线程标记为守护线程或用户线程

当正在运行的线程都是守护时，Java虚拟机退出。

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

守护线程即后台线程

当把某些线程标记为后台线程后，当前台线程都结束后，后台线程自动结束

中断线程

join()：等待该线程终止抛出InterruptedException

当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().toString()+"....."+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);

		t2.start();

		//t1.join();

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

toString

返回该线程的字符串表现形式，包括线程名称、优先级和线程组。
ThreadGroup线程组

是个对象可以new个对象吧线程组存入

优先级

设置优先级：setPriority(int a) a =1~ 10

MAX_PRIORITY 10

MIN_PRIORITY 1

NORM_PRIORITY 5

yield:

暂停当前正在执行的线程对象，并执行其他线程。

线程的一般写法

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

总结

进程：正在执行的程序。

线程：是进程中用于控制程序执行的控制单元(执行路径，执行情景)

进程中至少有一个线程。


对于JVM，启动时，只好有两个线程：jvm的主线程。jvm的垃圾回收线程。


如何在程序中自定义线程呢？

Java给我们提供了对象线程这类事物的描述。该类是Thread

该类中定义了，
创建线程对象的方法(构造函数).
提供了要被线程执行的代码存储的位置（run()）

还定义了开启线程运行的方法(start()).
同时还有一些其他的方法用于操作线程：
	static Thread currentThead():
	String getName():
	static void sleep(time)throws InterruptedException:


要运行的代码都是后期定义的。
所以创建线程的第一种方式是：继承Thread类。原因：要覆盖run方法，定义线程要运行的代码。

步骤：
1，继承Thread类。
2，覆盖run方法。将线程要运行的代码定义其中。
3，创建Thread类的子类对象，其实就是在创建线程，调用start方法。



如果自定义的类中有多线程要运行的代码。但是该类有自己的父类。
那么就不可以在继承Thread。怎么办呢？

Java给我们提供了一个规则。Runnable接口。
如果自定义类不继承Thread，也可以实现Runnable接口。并将多线程要运行的代码存放在Runnable的run方法中。
这样多线程也可以帮助该类运行。
这样的操作有一个好处：避免了单继承的局限性。

创建线程的第二种方式：实现Runnable接口。

步骤：
1，定义了实现Runnable接口。
2，覆盖接口的run方法。将多线程要运行的代码存入其中。
3，创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
	为什么要传递？因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象
	传递给Thread。让Thread线程去使用该对象调用其run方法。
4，调用Thread对象的start方法。开启线程。

动手写代码。


两种方式的特点：
实现方式，因为避免了单继承的局限性，所以创建线程建议使用第二种方式。


##############################
#第一重点：创建线程的两种方式#
##############################



作为了解：
线程的状态。
1，被创建。
2，运行。
3，冻结。
4，消亡。

其实还有一种特殊的状态：临时状态。

该临时状态的特点：
具备了执行资格，但不具备执行权。

冻结状态的特点：
放弃了执行资格。




多线程具备随机性。因为是由cpu不断的快速切换造成的。

就有可能会产生多线程的安全问题。

问题的产生的原因：
几个关键点：
1，多线程代码中有操作共享数据。
2，多条语句操作该共享数据。

当具备两个关键点时，
有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完，另一个线程开始参与执行。
就会发生数据错误。


解决方法：
当一个线程在执行多条操作共享数据代码时，其他线程即使获取了执行权，也不可以参与操作。


Java就对这种解决方式提供了专业的代码。
同步
同步的原理：就是将部分操作功能数据的代码进行加锁。

示例：火车上的卫生间。

同步的表现形式：
1，同步代码块。
2，同步函数。
两者有什么不同：
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。


注意：对于static的同步函数，使用的锁不是this。是 类名.class 是该类的字节码文件对象。
	涉及到了单例设计模式的懒汉式。


同步的好处：解决了线程的安全问题。

弊端：
	较为消耗资源。
	同步嵌套后，容易死锁。

要记住：同步使用的前提：
	1，必须是两个或者两个以上的线程。
	2，必须是多个线程使用同一个锁。
	这是才可以称为这些线程被同步了。

死锁代码一定会写。但开发时一定注意避免。



##############################
#第二重点：同步的所有特性    #
##############################

/*

class Thread 
{
	private Runnable target;

	Thread()
	{
	}
	Thread(Runnable target)
	{
		this.target = target;
	}

	public void run()
	{
		if(target!=null)
			target.run();
	}
}

class Test implements Runnable
{
	public void run()
	{}
}


main()
{
	Test q = new Test();
	Thread t = new Thread(q);
}


class Demo extends Thread
{
	public void run()
	{
	}
}
class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}
*/


/*

1，线程间通信。
	等待/唤醒机制。

	也就是常见的生产者消费者问题。

	1.当多个生产者消费者出现时，
	需要让获取执行权的线程判断标记。
	通过while完成。

	2.需要将对方的线程唤醒。
	仅仅用notify，是不可以的。因为有可能出现只唤醒本方。
	有可能会导致，所有线程都等待。
	所以可以通过notifyAll的形式来完成 。



这个程序有一个bug。就是每次notifyAll。都会唤醒本方。
可不可以只唤醒对方呢？

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

1，将synchronized 替换成了Lock接口。
	将隐式锁，升级成了显示锁。
	Lock
		获取锁：lock();
		释放锁：unlock();注意：释放的动作一定要执行，所以通常定义在finally中。
		获取Condition对象：newCondition();
2，将Object中的wait，notify，notifyAll方法都替换成了Condition的await，signal，signalAll。
	和以前不同是：一个同步代码块具备一个锁，该所以具备自己的独立wait和notify方法。
	现在是将wait，notify等方法，封装进一个特有的对象Condition，而一个Lock锁上可以有多个Condition对象。


	Lock lock = new ReentrantLock();

	Condition conA = lock.newCondition();
	Condition conB = lock.newCondition();

	con.await();//生产，，消费



	con.signal();生产


	set()
	{
		if(flag)
			conA.await();//生产者，
		code......;

		flag = true;
		conB.signal();
	}
	
	out()
	{
		if(!flag)
			conB.await();//消费者

		code....;
		flag = false;
		conA.signal();
	}



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


synchronized(锁)
{
	wait();
}


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

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



线程中一些常见方法：
	setDaemon(boolean):将线程标记为后台线程，后台线程和前台线程一样，开启，一样抢执行权运行，
	只有在结束时，有区别，当前台线程都运行结束后，后台线程会自动结束。

	join():什么意思？等待该线程结束。当A线程执行到了B的.join方法时，A就会处于冻结状态。
			A什么时候运行呢？当B运行结束后，A就会具备运行资格，继续运行。

	加入线程，可以完成对某个线程的临时加入执行。

	


多线程重点：
1，多线程的创建的两种方式，以及区别。

2，
	同步的特点。
	同步的好处：
	同步的弊端：
	同步的前提：
	同步的表现形式以及区别。
	特例：static同步函数锁是哪一个。

	死锁代码要求写的出来。


3，线程间通信，看以上总结。


4，wait和sleep，  yield：临时暂停，可以让线程是释放执行权。






*/