多线程

最新推荐文章于 2024-03-17 21:20:55 发布
最新推荐文章于 2024-03-17 21:20:55 发布
阅读量365 收藏 1
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012324102/article/details/53535641
版权


多线程

 

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

一个进程中，至少有一个线程。

主线程：Java虚拟机启动的时候就会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

扩展：

其实更细节说明虚拟机（jvm），jvm启动不止一个线程，还有负责垃圾回收的线程

 

如何在自定义的代码中，自定义一个线程呢？

通过对API的查找，java已经提供了对线程这类事物的描述。就是Thread类。

创建线程的第一种方式：继承Thread类。（通过查API表查到的）

步骤：

1、定义类继承Thread。

2、复写Thread类中的run方法。

目的：将自定义的代码存储在run方法中，让线程运行。

不覆写的话，运行的就是Thread类中的run方法。

3、调用线程的start方法。

该方法有两个作用：启动线程，调用run方法。

注意：其实，创建对象就是创建一个线程；调用这个对象的方法才是真正的启动这个线程。

Thread类用于描述线程。该类就定义一个功能，用于存储线程要运行的代码。该功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。

注意：运行结果每一次都不同。

因为多个线程都在获取CPU的执行使用权。CPU执行到哪个程序，该程序就运行。

明确一点，在某一时刻，只能有一个程序在运行。（多核除外）

其实是CPU在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象的把多线程的运行认为是在互相抢夺CPU的执行使用权。

这就是多线程的一个特性：随机性。

哪个程序先抢到就先执行，至于执行多长，CPU说了算。


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

步骤：

1、定义类实现Runnable 接口

2、覆盖Runnable 接口中的run方法

将线程要运行的代码存放在该run方法中。

3、通过Thread类建立线程对象

4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

为什么要将Runnable接口的子类对象传递给Thread类的构造函数？

因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定 指定对象 的run方法，就必须明确该run方法所属对象。

5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

 

实现方式和继承方式的区别：

继承Thread：  线程代码存放在Thread子类的run方法中。

实现Runnable：线程代码存放在接口的子类的run方法中。

实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现的方式

 

多线程的安全问题：

问题原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

JAVA对于多线程的安全问题，提供了专业的解决方式：就是同步代码块。

格式：

synchronized（对象）

{

需要被同步的代码块

}

 

*需要被同步的代码块：看哪些数据在操作共享数据，就属性需要被同步的代码块

对象如同锁。持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取了CPU的执行权，也进不去，因为没有获取锁。

 

同步的前提：

1、必须要有两个或者两个以上的线程。

2、必须是多个线程使用同一个锁。

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

同步的弊端：多个线程都需要判断锁，较为消耗资源。当然，这个资源是在允许的范围内。

必须保证同步中只有一个线程在运行。把run方法中的代码全部放在同步中，那就使得代码变成了单线程。

 

在程序中怎么找到多线程的安全问题：

1、明确哪些代码是多线程运行代码。

2、明确共享数据。

3、明确多线程运行代码中哪些语句是操作共享数据的。

 

同步函数中，如果操作共享数据的代码和别的代码混在一起

那么可以在这个类中将共享数据的代码拿出来封装进一个新的方法，构造同步函数，在原来的方法中只要调用这个方法就行了。

 

同步函数用的是哪个锁？

函数需要被对象调用，那么函数都有一个所属对象引用，就是this

所以同步函数使用的锁是this（可以用卖票的那个小程序进行验证）

 

同步函数被静态修饰后，锁是哪个？

通过验证，发现不是this，因为静态方法中也不可以定义this

静态进内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象。

类名.class  该对象的类型是Class

验证后发现，静态的同步方法，使用的锁是该方法所在类的字节码文件对象。

即：如果这个类是 class Demo{}；那么对象就是Demo.class 

  

线程间通信：

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

wait()；notify()；notifyAll()；

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

 

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

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

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

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

 

升级到JDK1.5之后，提供了多线程升级解决方案：

将同步synchronized 替换成显示Lock操作，将object中的wait，notify，notifyAll 替换成了condition 对象。该对象可以通过Lock锁进行获取，还可以实现本方只唤醒自己的操作。

 

停止线程：

Stop方法已经过时。

想要停止，只有run方法结束。

开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：interrupt()方法

当线程处于冻结状态，就不会读取到标记，线程就不会结束。

Interrupt:将处于冻结状态的线程，强制恢复到运行状态。即清除线程的冻结状态

 

守护线程：setDaemon(boolean)

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

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

 

Join()方法：

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

join（）方法，可以用于临时加入线程执行


习题：
生产者和消费者。
每生产出一个产品，卖出这个产品后再生产下一个产品，保证其有序性。

分析：
定义一个资源类，将生产和消费的方法都定义到这个类中，
用线程。

public class Demo8 
{
	public static void main(String[] args)
	{
		Res r = new Res();//创建资源类的对象
		Pro p = new Pro(r);//必有得有资源对象才能生产
		Cus c = new Cus(r);//必有得有资源对象才能卖出
		
		Thread t1 = new Thread(p);//两个线程生产
		Thread t2 = new Thread(p);
		Thread t3 = new Thread(c);//两个线程消费
		Thread t4 = new Thread(c);
		
		t1.start();//调用这几个线程的run方法
		t2.start();
		t3.start();
		t4.start();		
	}	
}
//资源类
class Res 
{
	private String name;//产品名
	private int num = 1;//产品编号
	private boolean flag;//标记，默认为false
	
	public synchronized void pro(String name)//生产方法
	{	
	// 定义while判断标记,是为了让被唤醒的线程再一次判断标记
		while (flag)
		{	
			try
			{wait();}
			catch(Exception e)
			{}//这里先省略处理方法
		}	
		//初始化时将编号一起赋给产品
		this.name = name+".."+num++;//必须把这个放在循环里面，要不就是先消费，后生产了
		System.out.println(Thread.currentThread().getName()+"...生产"+this.name);//这里必须加this.name
		flag = true ;
		//只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。所以用notifyAll唤醒所有等待线程
		this.notifyAll();		
	}
	public synchronized void cus()//消费已经生产出来的商品，所以这里的参数应该为空
	{
		while(!flag)
		{
			try
			{wait();}
			catch(Exception e){}
		}
		//Thread.currentThread().getName()，线程的名称
		System.out.println(Thread.currentThread().getName()+"......消费"+this.name);
		flag = false;
		this.notifyAll();
	}
}

class Pro implements Runnable
{
	private Res r;
	Pro(Res r)
	{
		this.r = r;
	}
	public void run()//覆盖接口中的方法
	{
		while(true)//无限循环的一种形式，为了更加直观的看出效果
		{
			r.pro("茶杯");//调用生产的方法，传入产品名称：茶杯
		}
	}
}

class Cus implements Runnable
{
	private Res r;
	Cus(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.cus();
		}
	}
}
输出结果： 

Thread-1...生产茶杯..101329
Thread-3......消费茶杯..101329
Thread-0...生产茶杯..101330
Thread-3......消费茶杯..101330
Thread-1...生产茶杯..101331
Thread-2......消费茶杯..101331
Thread-1...生产茶杯..101332
Thread-3......消费茶杯..101332
Thread-0...生产茶杯..101333
Thread-3......消费茶杯..101333
Thread-1...生产茶杯..101334
Thread-2......消费茶杯..101334
Thread-1...生产茶杯..101335
Thread-3......消费茶杯..101335
Thread-0...生产茶杯..101336
Thread-3......消费茶杯..101336
Thread-1...生产茶杯..101337
Thread-2......消费茶杯..101337
Thread-1...生产茶杯..101338
Thread-3......消费茶杯..101338
Thread-0...生产茶杯..101339
Thread-3......消费茶杯..101339
Thread-1...生产茶杯..101340
Thread-2......消费茶杯..101340
Thread-1...生产茶杯..101341
Thread-3......消费茶杯..101341
Thread-0...生产茶杯..101342
Thread-3......消费茶杯..101342
Thread-1...生产茶杯..101343
Thread-2......消费茶杯..101343
Thread-1...生产茶杯..101344
Thread-3......消费茶杯..101344
Thread-0...生产茶杯..101345
Thread-3......消费茶杯..101345

升级到JDK1.5之后，提供了多线程升级解决方案：

将同步synchronized 替换成显示Lock操作，将object中的wait，notify，notifyAll 替换成了condition 对象。该对象可以通过Lock锁进行获取，还可以实现本方只唤醒自己的操作。

 * Lock:替代了Synchronized
	lock 
	unlock
	newCondition()

Condition：替代了Object wait notify notifyAll
	await();
	signal();
	signalAll();
 */

package Thread;
import java.util.concurrent.locks.*;//导入包

public class Demo9 
{
	public static void main(String[] args)
	{
		Resource r = new Resource();
		Produce p = new Produce(r);
		Customer c = new Customer(r);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		Thread t3 = new Thread(c);
		Thread t4 = new Thread(c);
		t1.start();//调用线程的run方法
		t2.start();
		t3.start();
		t4.start();
	}
}

class Resource
{
	private String name;
	private int num;
	private boolean flag;
	private Lock lock = new ReentrantLock();
	//Condition condition = lock.newCondition(); 
	 //让对应的对象等待，然后在用对应的对象唤醒该对象，所以可以用下面的方法
	private Condition condition_pro = lock.newCondition();
	private Condition condition_cus = lock.newCondition();

	public void pro(String name)throws InterruptedException 
	{
		lock.lock();//加锁
		try
		{ 
			//await()方法在while里面，每次被唤醒都需要判断一次条件flag
			while(flag)
			{
				condition_pro.await();//在pro方法里面，让pro方法等待
			}	
			this.name = name + "...."+num++;//让编号随着产品的增加而增加
			System.out.println(Thread.currentThread().getName()+"...生产.."+this.name);
			flag = true;
			condition_cus.signal();//唤醒cus对象		
		 }
		finally//执行完后释放锁
		{
			lock.unlock();//释放锁
		}
	}
	public void cus()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
			{
				condition_cus.await();//在cus方法里，让cus方法等待
			}	
			System.out.println(Thread.currentThread().getName()+".....消费....."+this.name);
			flag = false;
			condition_pro.signal();//唤醒pro方法		
		}
		finally
		{
			lock.unlock();
		}
	}
 
}

class Produce implements Runnable
{
	private Resource res;
	Produce(Resource res)
	{
		this.res = res;
	}
	
	public void run()
	{
		while(true)
		{
			try
			{
				res.pro("茶杯");
			}
			catch(InterruptedException e)
			{}
		}
	}
}

class Customer implements Runnable
{
	private Resource res;
	Customer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{res.cus();}
			catch(InterruptedException e)
			{}
		}
	}
}

输出结果： 

Thread-0...生产..茶杯....58658
Thread-3.....消费.....茶杯....58658
Thread-1...生产..茶杯....58659
Thread-2.....消费.....茶杯....58659
Thread-0...生产..茶杯....58660
Thread-3.....消费.....茶杯....58660
Thread-1...生产..茶杯....58661
Thread-2.....消费.....茶杯....58661
Thread-0...生产..茶杯....58662
Thread-3.....消费.....茶杯....58662
Thread-1...生产..茶杯....58663
Thread-2.....消费.....茶杯....58663
Thread-0...生产..茶杯....58664
Thread-3.....消费.....茶杯....58664
Thread-1...生产..茶杯....58665
Thread-2.....消费.....茶杯....58665
Thread-0...生产..茶杯....58666
Thread-3.....消费.....茶杯....58666
Thread-1...生产..茶杯....58667
Thread-2.....消费.....茶杯....58667
Thread-0...生产..茶杯....58668
Thread-3.....消费.....茶杯....58668
Thread-1...生产..茶杯....58669
Thread-2.....消费.....茶杯....58669
Thread-0...生产..茶杯....58670
Thread-3.....消费.....茶杯....58670
Thread-1...生产..茶杯....58671
Thread-2.....消费.....茶杯....58671
Thread-0...生产..茶杯....58672
Thread-3.....消费.....茶杯....58672







多线程

 

进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

一个进程中，至少有一个线程。

主线程：Java虚拟机启动的时候就会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。

扩展：

其实更细节说明虚拟机（jvm），jvm启动不止一个线程，还有负责垃圾回收的线程

 

如何在自定义的代码中，自定义一个线程呢？

通过对API的查找，java已经提供了对线程这类事物的描述。就是Thread类。

创建线程的第一种方式：继承Thread类。（通过查API表查到的）

步骤：

1、定义类继承Thread。

2、复写Thread类中的run方法。

目的：将自定义的代码存储在run方法中，让线程运行。

不覆写的话，运行的就是Thread类中的run方法。

3、调用线程的start方法。

该方法有两个作用：启动线程，调用run方法。

注意：其实，创建对象就是创建一个线程；调用这个对象的方法才是真正的启动这个线程。

Thread类用于描述线程。该类就定义一个功能，用于存储线程要运行的代码。该功能就是run方法。也就是说Thread类中的run方法，用于存储线程要运行的代码。

注意：运行结果每一次都不同。

因为多个线程都在获取CPU的执行使用权。CPU执行到哪个程序，该程序就运行。

明确一点，在某一时刻，只能有一个程序在运行。（多核除外）

其实是CPU在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象的把多线程的运行认为是在互相抢夺CPU的执行使用权。

这就是多线程的一个特性：随机性。

哪个程序先抢到就先执行，至于执行多长，CPU说了算。


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

步骤：

1、定义类实现Runnable 接口

2、覆盖Runnable 接口中的run方法

将线程要运行的代码存放在该run方法中。

3、通过Thread类建立线程对象

4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

为什么要将Runnable接口的子类对象传递给Thread类的构造函数？

因为，自定义的run方法所属的对象是Runnable接口的子类对象。所以要让线程去指定 指定对象 的run方法，就必须明确该run方法所属对象。

5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

 

实现方式和继承方式的区别：

继承Thread：  线程代码存放在Thread子类的run方法中。

实现Runnable：线程代码存放在接口的子类的run方法中。

实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现的方式

 

多线程的安全问题：

问题原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

JAVA对于多线程的安全问题，提供了专业的解决方式：就是同步代码块。

格式：

synchronized（对象）

{

需要被同步的代码块

}

 

*需要被同步的代码块：看哪些数据在操作共享数据，就属性需要被同步的代码块

对象如同锁。持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取了CPU的执行权，也进不去，因为没有获取锁。

 

同步的前提：

1、必须要有两个或者两个以上的线程。

2、必须是多个线程使用同一个锁。

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

同步的弊端：多个线程都需要判断锁，较为消耗资源。当然，这个资源是在允许的范围内。

必须保证同步中只有一个线程在运行。把run方法中的代码全部放在同步中，那就使得代码变成了单线程。

 

在程序中怎么找到多线程的安全问题：

1、明确哪些代码是多线程运行代码。

2、明确共享数据。

3、明确多线程运行代码中哪些语句是操作共享数据的。

 

同步函数中，如果操作共享数据的代码和别的代码混在一起

那么可以在这个类中将共享数据的代码拿出来封装进一个新的方法，构造同步函数，在原来的方法中只要调用这个方法就行了。

 

同步函数用的是哪个锁？

函数需要被对象调用，那么函数都有一个所属对象引用，就是this

所以同步函数使用的锁是this（可以用卖票的那个小程序进行验证）

 

同步函数被静态修饰后，锁是哪个？

通过验证，发现不是this，因为静态方法中也不可以定义this

静态进内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象。

类名.class  该对象的类型是Class

验证后发现，静态的同步方法，使用的锁是该方法所在类的字节码文件对象。

即：如果这个类是 class Demo{}；那么对象就是Demo.class 

  

线程间通信：

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

wait()；notify()；notifyAll()；

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

 

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

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

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

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

 

升级到JDK1.5之后，提供了多线程升级解决方案：

将同步synchronized 替换成显示Lock操作，将object中的wait，notify，notifyAll 替换成了condition 对象。该对象可以通过Lock锁进行获取，还可以实现本方只唤醒自己的操作。

 

停止线程：

Stop方法已经过时。

想要停止，只有run方法结束。

开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：interrupt()方法

当线程处于冻结状态，就不会读取到标记，线程就不会结束。

Interrupt:将处于冻结状态的线程，强制恢复到运行状态。即清除线程的冻结状态

 

守护线程：setDaemon(boolean)

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

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

 

Join()方法：

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

join（）方法，可以用于临时加入线程执行


习题：
生产者和消费者。
每生产出一个产品，卖出这个产品后再生产下一个产品，保证其有序性。

分析：
定义一个资源类，将生产和消费的方法都定义到这个类中，
用线程。

public class Demo8 
{
	public static void main(String[] args)
	{
		Res r = new Res();//创建资源类的对象
		Pro p = new Pro(r);//必有得有资源对象才能生产
		Cus c = new Cus(r);//必有得有资源对象才能卖出
		
		Thread t1 = new Thread(p);//两个线程生产
		Thread t2 = new Thread(p);
		Thread t3 = new Thread(c);//两个线程消费
		Thread t4 = new Thread(c);
		
		t1.start();//调用这几个线程的run方法
		t2.start();
		t3.start();
		t4.start();		
	}	
}
//资源类
class Res 
{
	private String name;//产品名
	private int num = 1;//产品编号
	private boolean flag;//标记，默认为false
	
	public synchronized void pro(String name)//生产方法
	{	
	// 定义while判断标记,是为了让被唤醒的线程再一次判断标记
		while (flag)
		{	
			try
			{wait();}
			catch(Exception e)
			{}//这里先省略处理方法
		}	
		//初始化时将编号一起赋给产品
		this.name = name+".."+num++;//必须把这个放在循环里面，要不就是先消费，后生产了
		System.out.println(Thread.currentThread().getName()+"...生产"+this.name);//这里必须加this.name
		flag = true ;
		//只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。所以用notifyAll唤醒所有等待线程
		this.notifyAll();		
	}
	public synchronized void cus()//消费已经生产出来的商品，所以这里的参数应该为空
	{
		while(!flag)
		{
			try
			{wait();}
			catch(Exception e){}
		}
		//Thread.currentThread().getName()，线程的名称
		System.out.println(Thread.currentThread().getName()+"......消费"+this.name);
		flag = false;
		this.notifyAll();
	}
}

class Pro implements Runnable
{
	private Res r;
	Pro(Res r)
	{
		this.r = r;
	}
	public void run()//覆盖接口中的方法
	{
		while(true)//无限循环的一种形式，为了更加直观的看出效果
		{
			r.pro("茶杯");//调用生产的方法，传入产品名称：茶杯
		}
	}
}

class Cus implements Runnable
{
	private Res r;
	Cus(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.cus();
		}
	}
}
输出结果： 

Thread-1...生产茶杯..101329
Thread-3......消费茶杯..101329
Thread-0...生产茶杯..101330
Thread-3......消费茶杯..101330
Thread-1...生产茶杯..101331
Thread-2......消费茶杯..101331
Thread-1...生产茶杯..101332
Thread-3......消费茶杯..101332
Thread-0...生产茶杯..101333
Thread-3......消费茶杯..101333
Thread-1...生产茶杯..101334
Thread-2......消费茶杯..101334
Thread-1...生产茶杯..101335
Thread-3......消费茶杯..101335
Thread-0...生产茶杯..101336
Thread-3......消费茶杯..101336
Thread-1...生产茶杯..101337
Thread-2......消费茶杯..101337
Thread-1...生产茶杯..101338
Thread-3......消费茶杯..101338
Thread-0...生产茶杯..101339
Thread-3......消费茶杯..101339
Thread-1...生产茶杯..101340
Thread-2......消费茶杯..101340
Thread-1...生产茶杯..101341
Thread-3......消费茶杯..101341
Thread-0...生产茶杯..101342
Thread-3......消费茶杯..101342
Thread-1...生产茶杯..101343
Thread-2......消费茶杯..101343
Thread-1...生产茶杯..101344
Thread-3......消费茶杯..101344
Thread-0...生产茶杯..101345
Thread-3......消费茶杯..101345

升级到JDK1.5之后，提供了多线程升级解决方案：

将同步synchronized 替换成显示Lock操作，将object中的wait，notify，notifyAll 替换成了condition 对象。该对象可以通过Lock锁进行获取，还可以实现本方只唤醒自己的操作。

 * Lock:替代了Synchronized
	lock 
	unlock
	newCondition()

Condition：替代了Object wait notify notifyAll
	await();
	signal();
	signalAll();
 */

package Thread;
import java.util.concurrent.locks.*;//导入包

public class Demo9 
{
	public static void main(String[] args)
	{
		Resource r = new Resource();
		Produce p = new Produce(r);
		Customer c = new Customer(r);
		Thread t1 = new Thread(p);
		Thread t2 = new Thread(p);
		Thread t3 = new Thread(c);
		Thread t4 = new Thread(c);
		t1.start();//调用线程的run方法
		t2.start();
		t3.start();
		t4.start();
	}
}

class Resource
{
	private String name;
	private int num;
	private boolean flag;
	private Lock lock = new ReentrantLock();
	//Condition condition = lock.newCondition(); 
	 //让对应的对象等待，然后在用对应的对象唤醒该对象，所以可以用下面的方法
	private Condition condition_pro = lock.newCondition();
	private Condition condition_cus = lock.newCondition();

	public void pro(String name)throws InterruptedException 
	{
		lock.lock();//加锁
		try
		{ 
			//await()方法在while里面，每次被唤醒都需要判断一次条件flag
			while(flag)
			{
				condition_pro.await();//在pro方法里面，让pro方法等待
			}	
			this.name = name + "...."+num++;//让编号随着产品的增加而增加
			System.out.println(Thread.currentThread().getName()+"...生产.."+this.name);
			flag = true;
			condition_cus.signal();//唤醒cus对象		
		 }
		finally//执行完后释放锁
		{
			lock.unlock();//释放锁
		}
	}
	public void cus()throws InterruptedException
	{
		lock.lock();
		try
		{
			while(!flag)
			{
				condition_cus.await();//在cus方法里，让cus方法等待
			}	
			System.out.println(Thread.currentThread().getName()+".....消费....."+this.name);
			flag = false;
			condition_pro.signal();//唤醒pro方法		
		}
		finally
		{
			lock.unlock();
		}
	}
 
}

class Produce implements Runnable
{
	private Resource res;
	Produce(Resource res)
	{
		this.res = res;
	}
	
	public void run()
	{
		while(true)
		{
			try
			{
				res.pro("茶杯");
			}
			catch(InterruptedException e)
			{}
		}
	}
}

class Customer implements Runnable
{
	private Resource res;
	Customer(Resource res)
	{
		this.res = res;
	}
	public void run()
	{
		while(true)
		{
			try
			{res.cus();}
			catch(InterruptedException e)
			{}
		}
	}
}

输出结果： 

Thread-0...生产..茶杯....58658
Thread-3.....消费.....茶杯....58658
Thread-1...生产..茶杯....58659
Thread-2.....消费.....茶杯....58659
Thread-0...生产..茶杯....58660
Thread-3.....消费.....茶杯....58660
Thread-1...生产..茶杯....58661
Thread-2.....消费.....茶杯....58661
Thread-0...生产..茶杯....58662
Thread-3.....消费.....茶杯....58662
Thread-1...生产..茶杯....58663
Thread-2.....消费.....茶杯....58663
Thread-0...生产..茶杯....58664
Thread-3.....消费.....茶杯....58664
Thread-1...生产..茶杯....58665
Thread-2.....消费.....茶杯....58665
Thread-0...生产..茶杯....58666
Thread-3.....消费.....茶杯....58666
Thread-1...生产..茶杯....58667
Thread-2.....消费.....茶杯....58667
Thread-0...生产..茶杯....58668
Thread-3.....消费.....茶杯....58668
Thread-1...生产..茶杯....58669
Thread-2.....消费.....茶杯....58669
Thread-0...生产..茶杯....58670
Thread-3.....消费.....茶杯....58670
Thread-1...生产..茶杯....58671
Thread-2.....消费.....茶杯....58671
Thread-0...生产..茶杯....58672
Thread-3.....消费.....茶杯....58672







百事丶可乐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
stm32单片机多线程实例
12-03
多线程是实现复杂任务并发执行的关键技术，能够提高资源利用率，优化系统响应时间。在STM32上实现多线程，通常会借助实时操作系统（RTOS）如RT-Thread。 RT-Thread是一个轻量级、开源的实时操作系统，它为STM32等微...
一文详解C++多线程
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的 。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
Java多线程超详解
weixin_44797490的博客
06-11 14万+
引言 随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。 那么话不多说，今天本帅将记录自己线程的学习。 线程的相关API //获取当前线程的名字 Thread.currentThread().getName() 1.start():1.启动当前线程2.调用线程中的run方法 2.run():通常需要重写Thread类中的此...
万字图解Java多线程
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程（超详细！）
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
C++多线程详细讲解
qq_45439571的博客
03-19 4万+
本文是纯转载，觉得大佬写的非常好！如有侵权可以删除 链接: link. C++多线程基础教程 目录 1 什么是C++多线程？ 2 C++多线程基础知识 2.1 创建线程 2.2 互斥量使用 lock()与unlock(): lock_guard(): unique_lock: condition_variable: 2.3 异步线程 async与future： shared_future 2.4 原子类型automic 实例 生产者消费者问题 4 C++多线程高级知识 4.1 线程池 线程池基础知识 线程池
java多线程（超详细）
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程实战-CountDownLatch模拟压测实现
最新发布
qq_35716689的博客
03-17 17万+
当多个线程需要协调和同步执行任务时，Java 中的 CountDownLatch（倒计时器）是一个常用的工具类。它可以帮助开发者实现线程之间的同步，确保某些线程在其他线程完成任务后再继续执行。牵着猫散步的鼠鼠。本文将介绍 CountDownLatch 的基本原理、用法以及示例代码，最后会使用CountDownLatch完成一个简单的压测实现。
Java多线程学习（吐血超详细总结）
热门推荐
Evankaka的专栏
03-14 41万+
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。
Python多线程详解
千山暮彩
10-30 5万+
现代计算机CPU物理核心普遍比较多，我们在编写程序时经常会用到多线程技术来提高程序运行的效率。作为python萌新，我在掌握基本语法后就很想摆弄一下python的多线程，使用起来确实很有python的特点，代码量少、操作方便。之后断断续续写了一些多线程程序，直到今天下午逛论坛，看到很多人说python多线程机制的一些内情，我才意识到自己有多愚蠢哈哈。我把自己学到的内容系统的整理一下，以备后忘，也帮帮后来者。
多线程测试
09-21
在计算机科学领域，多线程是一种程序设计技术，它允许应用程序同时执行多个任务或子任务。这极大地提高了软件的效率和响应性，特别是在现代多核处理器的环境下。本主题将深入探讨多线程的实现方式及其与单线程的对比...
大漠多线程模板_大漠_大漠多线程_
09-30
"大漠多线程模板"是一个专门针对C#开发的多线程处理框架，它为开发者提供了便捷的方式来管理和优化多线程应用。这个框架由知名开发者"大漠"创建，旨在简化复杂的并发编程，提高代码的可读性和可维护性。 多线程允许...
安卓多线程
04-16
安卓多线程，安卓高级开发中，必备技能，项目开发中都要使用
多线程基础与基于多线程的简单聊天室
06-24
在IT行业中，多线程是程序设计中的一个重要概念，尤其在Java编程中，它被广泛应用于提高应用程序的并发性能和响应速度。本压缩包“多线程基础与基于多线程的简单聊天室”提供了对多线程技术的实践理解和二次开发的...
多线程示例
03-30
在IT领域，多线程是程序设计中的一个重要概念，尤其在现代计算机系统中，它能够提升应用程序的效率和响应性。MFC（Microsoft Foundation Classes）是微软提供的一个C++类库，用于简化Windows应用程序的开发，包括...
qt websocket 客户端 多线程使用
09-16
qt 使用QWebSocket 创建websocket客户端来读取数据，异步链接，并且放入到线程中去执行，线程池的基础，代码使用两个用户，放入到一个线程中执行，同理，可以多个用户放入到多个线程中执行，为线程池执行websocket ...
WPF多线程实例
05-08
在Windows Presentation Foundation（WPF）开发中，多线程是一个重要的技术，特别是在处理大量数据或进行耗时操作时，为了保持用户界面（UI）的响应性，通常会使用多线程来实现非UI任务。本实例是关于如何在WPF应用...
Windows多线程编程指南
"这份资料详细介绍了Windows环境下的多线程编程，包括Win32 API和MFC两种方式，以及线程间通信和线程同步的关键概念。适合初学者理解和实践多线程技术。" 在Windows操作系统中，多线程编程是解决程序执行效率和响应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值