黑马程序员——多线程

最新推荐文章于 2020-07-21 18:43:19 发布
最新推荐文章于 2020-07-21 18:43:19 发布
阅读量323 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mh2015cool/article/details/49902615
版权

黑马程序员--多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、定义

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

二、多线程作用

优点：多任务共同进行，防止后任务在一定时间内执行不到的问题发生。
弊端：线程如果太多，会导致效率降低。

多线程内部执行方式：

1、多线程运行结果的随机性：多线程中，线程间都会获取cpu的执行权，cpu执行到谁，谁就运行。
明确一点：某一时刻，只能有一个程序在运行（多核除外）。
2、cpu在做着快速的切换，已达到看上去是同时运行的效果。所以当线程过多时，cpu的切换次数会增多，
造成运行效率降低。所以，多线程的运行行为可看成互相抢夺cpu的执行权。
3、JVM 启动的时候会有一个进程 java.exe. 该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。该线程称之为主线程。
4、JVM也是一个多线程。JVM运行不止启动一个主线程，还有负责启动垃圾回收机制。

三、自定义线程

1、线程运行状态：被创建、运行、临时状态、冻结、消亡五种状态。

2、创建线程方式：
第一种方式：继承Thread类。
步骤：
a、定义类继承Thread
b、复写Thread类中的run方法。原因：每个线程都有自己的目的性。JVM将创建的主线程任务定义在主函数中（main）。
run方法就是Java给用户用于创建自己任务的区域。
c、调用线程的start()。start()有两个作用：a、启动线程；b、让java虚拟机调用该函数的run方法。
[java] view plain copy print ?
  1. //通过继承创建自己的线程   
  2. class Demo extends Thread  
  3. {  
  4.     public void run()  
  5.     {  
  6.         for(int x=0;x<5;x++)  
  7.             System.out.println("demo run--"+x);  
  8.     }  
  9. }  
  10. class RunDemo  
  11. {  
  12.     public static void main(String[] args)  
  13.     {  
  14.         //创建线程的目的：开启一条执行路径。可理解为抢夺资源。   
  15.         Demo a = new Demo();  
  16.   
  17.         //开启线程并执行该线程的run方法。可理解为：赛跑的信号枪。  
  18.         a.start();   
  19.   
  20.         //一般的对象调用方法。是一个强制性命令。系统会执行完run()后，再运行主函数。  
  21.         //a.run();   
  22.   
  23.         for(int x=0;x<5;x++)  
  24.             //用Thread类的getName()方法获取执行线程的名称。Thread.currentThread()==this;  
  25.             System.out.println("Hellow World--"+x+this.getName());  
  26.     }  
  27. }  
//通过继承创建自己的线程
class Demo extends Thread
{
	public void run()
	{
		for(int x=0;x<5;x++)
			System.out.println("demo run--"+x);
	}
}
class RunDemo
{
	public static void main(String[] args)
	{
		//创建线程的目的：开启一条执行路径。可理解为抢夺资源。
		Demo a = new Demo();

		//开启线程并执行该线程的run方法。可理解为：赛跑的信号枪。
		a.start(); 

		//一般的对象调用方法。是一个强制性命令。系统会执行完run()后，再运行主函数。
		//a.run();

		for(int x=0;x<5;x++)
			//用Thread类的getName()方法获取执行线程的名称。Thread.currentThread()==this;
			System.out.println("Hellow World--"+x+this.getName());
	}
}
多线程输出结果：


单线程执行结果：


第二种方式：实现Runnable接口。
该类实现run方法，然后可以分配该类的实例，在创建Thread时作为一个参数来传递并启动。
步骤：
a、定义类实现Runnable接口
b、覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。
c、通过Thread类建立线程对象。
d、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去执行指定对象的run方法，
就必须明确该run方法所属对象。（让你儿子去打酱油，你必须告诉他超市在哪）
e、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

[java] view plain copy print ?
  1. //实现Runnable，建立多线程   
  2. class Ticket implements Runnable //extends Thread  
  3. {  
  4.     //此处可定义static让数据变成共享数据。但一般不定义static，因为其寿命太长。  
  5.     private int tick = 100;  
  6.     public void run()  
  7.     {  
  8.         //while(true)：无限循环，增加问题出现的可能性。   
  9.         while(true)  
  10.         {  
  11.             if(tick>0)  
  12.             {  
  13.                 //Thread.currentThread()：获取当前线程对象。getName():获取线程名称。  
  14.                 System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);  
  15.             }  
  16.         }  
  17.     }  
  18. }  
  19.   
  20. class RunnableDemo  
  21. {  
  22.     public static void main(String[] args)  
  23.     {  
  24.         Ticket t = new Ticket();  
  25.         //创建线程，接收对象。   
  26.         Thread t1 = new Thread(t);  
  27.         Thread t2 = new Thread(t);  
  28.         Thread t3 = new Thread(t);  
  29.         Thread t4 = new Thread(t);        
  30.         t1.start();  
  31.         t2.start();  
  32.         t3.start();   
  33.         t4.start();   
  34.     }  
  35. }  
//实现Runnable，建立多线程
class Ticket implements Runnable //extends Thread
{
	//此处可定义static让数据变成共享数据。但一般不定义static，因为其寿命太长。
	private int tick = 100;
	public void run()
	{
		//while(true)：无限循环，增加问题出现的可能性。
		while(true)
		{
			if(tick>0)
			{
				//Thread.currentThread()：获取当前线程对象。getName():获取线程名称。
				System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);
			}
		}
	}
}

class RunnableDemo
{
	public static void main(String[] args)
	{
		Ticket t = new Ticket();
		//创建线程，接收对象。
		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);
		Thread t3 = new Thread(t);
		Thread t4 = new Thread(t);		
		t1.start();
		t2.start();
		t3.start(); 
		t4.start();	
	}
}
输出结果：


这两种方式的区别：
区别：两种方式都自定义了run方法，但是它们的run方法存放的地点不一样。


继承Thread：线程代码存放Thread子类run方法中；实现Runnable:线程代码存在接口的子类的run方法。
相比较而言，实现Runnable的方法更好。因为它避免了类单继承的局限性。

四、多线程类的安全问题：

问题原因：共享数据时，一个线程对多条语句未全部执行完时，另一个线程参与进来，导致共同操作数据的情况。
解决措施：将存在多条语句的共享数据进行封装，一个线程在执行完共享数据前，其他线程不可以参与执行。
1、同步：是指两个或多个随时间变化的量在变化过程中保持一定的相对关系。它被用于封装代码，保障执行线程的唯一性。
同步的前提：
a、必须是多线程；（>=2个线程）
b、必须是同一把锁；
c、必须保证同步中只有一个线程在运行。
2、同步的种类：
a、同步代码块。跟函数一样用来封装代码，它比函数多了一个同步性。
synchronized(对象)
{

        需要被同步的代码-->操作共享数据的语句
}
原理：对象如同锁。锁是一个公平的权限机制。它保障持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去。
优点：解决了多线程的安全问题； 弊端：多个线程需要判断锁，较消耗资源。
b、同步函数。赋予函数同步性。
public synchronized void add(){}


3、同步函数和同步代码块的区别：
a、同步函数的锁固定是this。因为函数需要被对象调用，那么函数都有一个所属对象引用-->this。
b、同步代码块的锁是任意对象。建议使用同步代码块，因为其针对性更强。
c、如果同步函数和同步代码块都使用this当锁，就可以实现同步。
d、静态的同步方法，使用的锁是该方法所在类的字节码文件对象（类名.class）
因为，静态用于成员的数据共享，它随着类的加载而加载。此时还没有创建对象，要保障锁的公平性就需要一个公有的事物，
类文件成为不二之选。

[java] view plain copy print ?
  1. /* 
  2. 同步代码块的锁是任意对象； 
  3. 同步函数的锁是this； 
  4. 静态的同步方法，使用的锁是该方法所在类的字节码文件对象：类名.class 
  5. */  
  6. class Ticket implements Runnable  
  7. {  
  8.     //加入静态，使tick成为成员共享数据   
  9.     private static int tick = 100;  
  10.     boolean flag = true;  
  11.     public void run()  
  12.     {  
  13.         if(flag)  
  14.         {  
  15.             while(true)  
  16.             {  
  17.                 //同步代码块。这里的锁是：Ticket.class  
  18.                 synchronized(Ticket.class)  
  19.                 {  
  20.                     if(tick>0)  
  21.                     {  
  22.                         try{Thread.sleep(10);}catch(Exception e){}  
  23.                         System.out.println(Thread.currentThread().getName()+".sale:"+tick--);  
  24.                     }  
  25.                 }  
  26.             }  
  27.         }  
  28.         else  
  29.             while(true)  
  30.                 show();  
  31.     }  
  32.     //同步函数   
  33.     public static synchronized void show()  
  34.     {  
  35.         if(tick>0)  
  36.         {  
  37.             try{Thread.sleep(10);}catch(Exception e){}  
  38.             System.out.println(Thread.currentThread().getName()+"....show:"+tick--);  
  39.         }         
  40.     }     
  41. }  
  42.   
  43. class StaticDemo  
  44. {  
  45.     public static void main(String[] args)  
  46.     {  
  47.         Ticket t = new Ticket();  
  48.   
  49.         Thread t1 = new Thread(t);  
  50.         Thread t2 = new Thread(t);            
  51.         t1.start();  
  52.         //休眠主函数，暂缓flag赋值，使得t1有机会执行。   
  53.         try{Thread.sleep(10);}catch(Exception e){}   
  54.         t.flag = false;  
  55.         t2.start();  
  56.     }  
  57. }  
/*
同步代码块的锁是任意对象；
同步函数的锁是this；
静态的同步方法，使用的锁是该方法所在类的字节码文件对象：类名.class
*/
class Ticket implements Runnable
{
	//加入静态，使tick成为成员共享数据
	private static int tick = 100;
	boolean flag = true;
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				//同步代码块。这里的锁是：Ticket.class
				synchronized(Ticket.class)
				{
					if(tick>0)
					{
						try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+".sale:"+tick--);
					}
				}
			}
		}
		else
			while(true)
				show();
	}
	//同步函数
	public static synchronized void show()
	{
		if(tick>0)
		{
			try{Thread.sleep(10);}catch(Exception e){}
			System.out.println(Thread.currentThread().getName()+"....show:"+tick--);
		}		
	}	
}

class StaticDemo
{
	public static void main(String[] args)
	{
		Ticket t = new Ticket();

		Thread t1 = new Thread(t);
		Thread t2 = new Thread(t);			
		t1.start();
		//休眠主函数，暂缓flag赋值，使得t1有机会执行。
		try{Thread.sleep(10);}catch(Exception e){} 
		t.flag = false;
		t2.start();
	}
}
输出结果：


4、如何找出线程安全问题：
a、明确哪些代码是多线程运行代码；
b、明确共享数据；
c、明确多线程运行代码中哪些语句是操作共享数据的。两句以上最容易出错。

五、单例设计模式中的问题  

懒汉式存在问题：懒汉式的特点在于实例的延时加载，这使得多线程访问时，会存在安全问题。
解决方法：加同步-->同步函数、同步代码块  加同步时，使用的锁是：该类所属的字节码文件对象（类名.class）
[java] view plain copy print ?
  1. /* 
  2. 单例设计模式： 
  3. 饿汉式：就是先初始化对象。因为它内部的共享数据只有一条，不存在共同操作数据的情形，所以简单、安全。  
  4. 懒汉式：方法被调用时，才建立对象（特点：存在延时加载）。 
  5. */  
  6. class Single  
  7. {  
  8.     private static Single s = null;  
  9.     private Single(){}  
  10.     public static Single getInstance()  
  11.     {  
  12.         //双重判断。可筛选数据，减少等待线程的数量，提高效率   
  13.         if(s==null)  
  14.         {  
  15.             //静态 使用锁的是该方法所在类的字节码文件对象  类名.class  
  16.             synchronized(Single.class)  
  17.             {  
  18.                 if(s==null)  
  19.                     //延时加载，多线程访问时，此处线程可能处于临时状态（阻塞），造成安全隐患。  
  20.                     s = new Single();  
  21.             }  
  22.         }  
  23.         return s;  
  24.     }  
  25. }  
/*
单例设计模式：
饿汉式：就是先初始化对象。因为它内部的共享数据只有一条，不存在共同操作数据的情形，所以简单、安全。 
懒汉式：方法被调用时，才建立对象（特点：存在延时加载）。
*/
class Single
{
	private static Single s = null;
	private Single(){}
	public static Single getInstance()
	{
		//双重判断。可筛选数据，减少等待线程的数量，提高效率
		if(s==null)
		{
			//静态 使用锁的是该方法所在类的字节码文件对象  类名.class
			synchronized(Single.class)
			{
				if(s==null)
					//延时加载，多线程访问时，此处线程可能处于临时状态（阻塞），造成安全隐患。
					s = new Single();
			}
		}
		return s;
	}
}

六、死锁

死锁：因为嵌套锁且互相持有锁执行权，造成的僵持局面。
[java] view plain copy print ?
  1. class Test implements Runnable  
  2. {  
  3.     private boolean flag;  
  4.     Test(boolean flag)  
  5.     {  
  6.         this.flag = flag;  
  7.     }  
  8.     public void run()  
  9.     {  
  10.         if(flag)  
  11.         {  
  12.             while(true)  
  13.             {  
  14.                 //locka嵌套lockb   
  15.                 synchronized(MyLock.locka)  
  16.                 {  
  17.                     System.out.println("if A");  
  18.                     synchronized(MyLock.lockb)  
  19.                     {  
  20.                         System.out.println("if B");               
  21.                     }  
  22.                 }  
  23.             }  
  24.         }  
  25.         else  
  26.         {  
  27.             while(true)  
  28.             {  
  29.                 //lockb嵌套locka  
  30.                 synchronized(MyLock.lockb)  
  31.                 {  
  32.                     System.out.println("else B");  
  33.                     synchronized(MyLock.locka)  
  34.                     {  
  35.                         System.out.println("else A");                 
  36.                     }  
  37.                 }  
  38.             }             
  39.         }  
  40.     }  
  41. }  
  42. class MyLock  
  43. {  
  44.     //创建两个对象，方便区别锁   
  45.     static Object locka = new Object();  
  46.     static Object lockb = new Object();  
  47. }  
  48.   
  49. class DeadLockTest  
  50. {  
  51.     public static void main(String[] args)  
  52.     {  
  53.         Thread t1 = new Thread(new Test(true));  
  54.         Thread t2 = new Thread(new Test(false));  
  55.         t1.start();  
  56.         t2.start();  
  57.     }  
  58. }  
class Test implements Runnable
{
	private boolean flag;
	Test(boolean flag)
	{
		this.flag = flag;
	}
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				//locka嵌套lockb
				synchronized(MyLock.locka)
				{
					System.out.println("if A");
					synchronized(MyLock.lockb)
					{
						System.out.println("if B");				
					}
				}
			}
		}
		else
		{
			while(true)
			{
				//lockb嵌套locka
				synchronized(MyLock.lockb)
				{
					System.out.println("else B");
					synchronized(MyLock.locka)
					{
						System.out.println("else A");				
					}
				}
			}			
		}
	}
}
class MyLock
{
	//创建两个对象，方便区别锁
	static Object locka = new Object();
	static Object lockb = new Object();
}

class DeadLockTest
{
	public static void main(String[] args)
	{
		Thread t1 = new Thread(new Test(true));
		Thread t2 = new Thread(new Test(false));
		t1.start();
		t2.start();
	}
}
输出结果：

七、线程间通讯--等待唤醒机制

等待唤醒机制：是统一资源分配和线程自我任务执行的协调机制。
1、涉及方法：
wait():让线程处于冻结状态，被wait的线程会被存储到线程池中。
notify():随机唤醒线程池中的一个线程；
notifyAll():唤醒线程池中的所有线程。
2、以上方法使用前提：
a、都使用在同步中。因为这些方法要求线程必须拥有锁，而只有同步才具有锁。
b、wait()和notify()必须是同一把锁。
3、以上方法被定义在Object类中。因为锁可以是任意对象，所以将可以被任意对象调用的方法定义在Object类中。

[java] view plain copy print ?
  1. /* 
  2. 线程间通信:资源共享机制 
  3. 注意： 
  4. 1、本例有两个同步，因为有两个共同操作数据。 
  5. 2、wait()、notify()、notyfyAll()被定义在Object类中。因为锁可以是任意对象，锁的方法具有通用性。 
  6. */  
  7. class Res  
  8. {  
  9.     //内部数据私有化   
  10.     private String name;  
  11.     private String sex;  
  12.     private boolean flag = false;  
  13.     //创建同步函数并初始化   
  14.     public synchronized void set(String name,String sex)  
  15.     {  
  16.         if(this.flag)  
  17.             //因为使用wait()会抛出中断异常，所以需要捕获、处理异常。  
  18.             try{this.wait();}catch(Exception e){}  
  19.         this.name = name;  
  20.         this.sex = sex;  
  21.         flag = true;  
  22.         //唤醒先排队的线程   
  23.         this.notify();  
  24.     }  
  25.     public synchronized void out()  
  26.     {  
  27.         if(!this.flag)  
  28.             //this.wait()：标识等待线程，保证只能被对应对象唤醒，防止嵌套锁时，唤醒错误。  
  29.             try{this.wait();}catch(Exception e){}  
  30.         System.out.println(this.name+"....."+this.sex);  
  31.         flag = false;  
  32.         this.notify();  
  33.     }  
  34. }  
  35.   
  36. class Input implements Runnable  
  37. {  
  38.     private Res r;  
  39.     Input(Res r)  
  40.     {  
  41.         this.r = r;  
  42.     }  
  43.     public void run()  
  44.     {  
  45.         int x = 0;  
  46.         while(true)  
  47.         {  
  48.             if(x==0)  
  49.                 r.set("erwa","niangpao");  
  50.             else   
  51.                 r.set("翠花","娘们儿");  
  52.             //进行if、else切换   
  53.             x = (x+1)%2;  
  54.         }  
  55.     }     
  56. }  
  57.   
  58. class Output implements Runnable  
  59. {  
  60.     private Res r;  
  61.     //Input、Output都初始化r，保证了数据的唯一性。  
  62.     Output(Res r)  
  63.     {  
  64.         this.r = r;  
  65.     }  
  66.     public void run()  
  67.     {  
  68.         while(true)  
  69.         {  
  70.             r.out();  
  71.         }  
  72.     }  
  73. }  
  74. class InputOutputDemo  
  75. {  
  76.     public static void main(String[] args)  
  77.     {  
  78.         //创建资源   
  79.         Res r = new Res();  
  80.         //创建线程、接收对象，并运行   
  81.         new Thread(new Input(r)).start();  
  82.         new Thread(new Output(r)).start();  
  83.     }  
  84. }  
/*
线程间通信:资源共享机制
注意：
1、本例有两个同步，因为有两个共同操作数据。
2、wait()、notify()、notyfyAll()被定义在Object类中。因为锁可以是任意对象，锁的方法具有通用性。
*/
class Res
{
	//内部数据私有化
	private String name;
	private String sex;
	private boolean flag = false;
	//创建同步函数并初始化
	public synchronized void set(String name,String sex)
	{
		if(this.flag)
			//因为使用wait()会抛出中断异常，所以需要捕获、处理异常。
			try{this.wait();}catch(Exception e){}
		this.name = name;
		this.sex = sex;
		flag = true;
		//唤醒先排队的线程
		this.notify();
	}
	public synchronized void out()
	{
		if(!this.flag)
			//this.wait()：标识等待线程，保证只能被对应对象唤醒，防止嵌套锁时，唤醒错误。
			try{this.wait();}catch(Exception e){}
		System.out.println(this.name+"....."+this.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("erwa","niangpao");
			else 
				r.set("翠花","娘们儿");
			//进行if、else切换
			x = (x+1)%2;
		}
	}	
}

class Output implements Runnable
{
	private Res r;
	//Input、Output都初始化r，保证了数据的唯一性。
	Output(Res r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}
class InputOutputDemo
{
	public static void main(String[] args)
	{
		//创建资源
		Res r = new Res();
		//创建线程、接收对象，并运行
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
	}
}
输出结果：

PS：
1、wait和死锁的区别：wait是全部放弃执行资格；死锁是全都有执行权，但陷入执行僵局。
2、notify()和notifyAll()区别：notify()唤醒线程池中先存入的wait对象；notifyAll():全部唤醒，不按存入顺序唤醒。

八、接口Lock

JDK1.5中提供了多线程升级解决方案：
a、用实现Lock代替同步synchronized操作；
b、用Condition对象替换wait、notify、notifyAll方法。它通过Lock锁进行获取。格式：Condition c = Lock.newCondition();
好处：
a、提供了显示的锁机制和显示的锁对象上的等待、唤醒操作机制。
b、同时将wait、notify成condition对象，使一个锁可以控制多个condition对象，这样我们就可以随意选择唤醒对象。
避免了之前一个锁对应一个wait、notify的情形，防止了死锁的发生。
[java] view plain copy print ?
  1. //导入锁包   
  2. import java.util.concurrent.locks.*;  
  3.   
  4. class Resource  
  5. {  
  6.     private String name;  
  7.     private int count = 1;  
  8.     private boolean flag = false;  
  9.   
  10.     //创建锁   
  11.     private Lock lock = new ReentrantLock();  
  12.   
  13.     //Condition()用于替代wait、notify、notifyAll  
  14.     private Condition condition_pro = lock.newCondition();  
  15.     private Condition condition_con = lock.newCondition();  
  16.   
  17.     public void set(String name)throws InterruptedException  
  18.     {  
  19.         //调用锁   
  20.         lock.lock();  
  21.         try  
  22.         {  
  23.             while(flag)  
  24.                 //生产者线程等待   
  25.                 condition_pro.await();  
  26.             this.name = name+"..."+count++;  
  27.   
  28.             System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);  
  29.             flag = true;  
  30.             //唤醒消费者线程   
  31.             condition_con.signal();  
  32.         }  
  33.         finally  
  34.         {  
  35.             //用finally保障一定会执行释放锁的动作。  
  36.             lock.unlock();  
  37.         }  
  38.     }  
  39.     public void out()throws InterruptedException  
  40.     {  
  41.         lock.lock();  
  42.         try  
  43.         {  
  44.             while(!flag)  
  45.                 //消费者线程等待   
  46.                 condition_con.await();  
  47.             System.out.println(Thread.currentThread().getName()+"..........消费者..."+this.name);  
  48.             flag = false;  
  49.             //唤醒生产者线程   
  50.             condition_pro.signal();  
  51.         }  
  52.         finally  
  53.         {  
  54.             lock.unlock();  
  55.         }  
  56.     }  
  57. }  
  58.   
  59. class Producer implements Runnable  
  60. {  
  61.     private Resource res;  
  62.   
  63.     Producer(Resource res)  
  64.     {  
  65.         this.res = res;  
  66.     }  
  67.     public void run()  
  68.     {  
  69.         while(true)  
  70.         {  
  71.             try  
  72.             {  
  73.                 res.set("+商品+");  
  74.             }  
  75.             catch(InterruptedException e)  
  76.             {  
  77.             }  
  78.         }  
  79.     }  
  80. }  
  81. class Consumer implements Runnable  
  82. {  
  83.     private Resource res;  
  84.   
  85.     Consumer(Resource res)  
  86.     {  
  87.         this.res = res;  
  88.     }  
  89.     public void run()  
  90.     {  
  91.         while(true)  
  92.         {  
  93.             try  
  94.             {  
  95.                 res.out();  
  96.             }  
  97.             catch(InterruptedException e)  
  98.             {  
  99.             }             
  100.         }  
  101.     }  
  102. }  
  103. class ProducerConsumer2  
  104. {  
  105.     public static void main(String[] args)  
  106.     {  
  107.         Resource r = new Resource();  
  108.   
  109.         Producer pro = new Producer(r);  
  110.         Consumer con = new Consumer(r);  
  111.           
  112.         Thread t1 = new Thread(pro);  
  113.         Thread t2 = new Thread(pro);  
  114.         Thread t3 = new Thread(con);  
  115.         Thread t4 = new Thread(con);  
  116.   
  117.         t1.start();  
  118.         t2.start();  
  119.         t3.start();  
  120.         t4.start();  
  121.     }  
  122. }  
//导入锁包
import java.util.concurrent.locks.*;

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;

	//创建锁
	private Lock lock = new ReentrantLock();

	//Condition()用于替代wait、notify、notifyAll
	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
		{
			//用finally保障一定会执行释放锁的动作。
			lock.unlock();
		}
	}
	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)
			{
			}			
		}
	}
}
class ProducerConsumer2
{
	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();
	}
}
输出结果：

九、线程的停止

停止方式：让run方法结束；方法：控制循环。因为线程都是循环结构；特殊情况：interrupt()。 
interrupt()：将处于冻结状态（中断状态）的线程，强制恢复到运行状态中来。注意：中断状态不是停止状态（stop）。
守护线程（后台线程）和前台线程的启动、运行都一样，只有结束不同-->当所有前台线程都结束后，后台线程会自动结束。
setDaemon():将该线程标记为守护线程或用户线程。就是后台线程、辅助线程。必须在启动线程前调用。

[java] view plain copy print ?
  1. class StopThread implements Runnable  
  2. {  
  3.     private boolean flag = true;  
  4.     public synchronized void run()  
  5.     {  
  6.         while(flag)  
  7.         {  
  8.             try  
  9.             {  
  10.                 //加入线程等待方法，线程会陷入冻结状态，程序无法运行。  
  11.                 wait();  
  12.             }  
  13.             catch(InterruptedException e)  
  14.             {  
  15.                 System.out.println(Thread.currentThread().getName()+"...Exception");  
  16.   
  17.                 //改变标记，限制线程进入，使程序正常结束。  
  18.                 flag = false;  
  19.             }  
  20.             System.out.println(Thread.currentThread().getName()+"...run");  
  21.         }  
  22.     }  
  23.     //通过改变标记，控制循环   
  24.     public void changeFlag()  
  25.     {  
  26.         flag = false;  
  27.     }  
  28. }  
  29.   
  30. class StopThreadDemo  
  31. {  
  32.     public static void main(String[] args)  
  33.     {  
  34.         StopThread st = new StopThread();  
  35.   
  36.         Thread t1 = new Thread(st);   
  37.         Thread t2 = new Thread(st);  
  38.           
  39.         //守护线程（后台线程）：当所有前台线程都结束后，后台线程会自动结束。  
  40.         t1.setDaemon(true);   
  41.         t2.setDaemon(true);   
  42.         t1.start();  
  43.         t2.start();  
  44.   
  45.         int num = 0;  
  46.         while(true)  
  47.         {  
  48.             if(num++ == 3)  
  49.             {  
  50.                 //调用changeFlag()，改变循环，停止线程  
  51.                 st.changeFlag();  
  52.   
  53.                 //interrupt()：将处于冻结状态的线程，强制恢复到运行状态中来。  
  54.                 //t1.interrupt();   
  55.                 //t2.interrupt();  
  56.                 break;  
  57.             }  
  58.             System.out.println(Thread.currentThread().getName()+"....."+num);  
  59.         }  
  60.         System.out.println("over");  
  61.     }  
  62. }  
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.setDaemon(true); 
		t2.setDaemon(true); 
		t1.start();
		t2.start();

		int num = 0;
		while(true)
		{
			if(num++ == 3)
			{
				//调用changeFlag()，改变循环，停止线程
				st.changeFlag();

				//interrupt()：将处于冻结状态的线程，强制恢复到运行状态中来。
				//t1.interrupt();
				//t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"....."+num);
		}
		System.out.println("over");
	}
}
interrupt运行结果：

setDaemon输出结果：


PS：
1、join()：插队。它的加入会使主线程进入冻结状态，相当于插了主线程的队。
当A线程执行到了B线程的join()方法时，A线程就会等待，等B线程都执行完，A才会执行。
作用：用来临时加入线程执行。
2、toString():返回该线程的字符串形式，包括线程名称、优先级、线程组。
线程组：一般情况下，谁开启你的，谁就是你的线程组。 
3、ThreadGroup():构造新新线程组。
优先级：代表抢cpu资源的频率。系统默认为5。 
4、setPriority():设置线程优先级。MAX_PRIORITY MIN_PRIORITY NORM_PRIORITY
5、yield():暂停当前正在执行的线程对象，并执行其他线程。

十、小事例

[java] view plain copy print ?
  1. /* 
  2. 多线程的小事例: 
  3. 当某些线程需要同时运行时，就将其单独封装，用多线程运行。 
  4. */  
  5. class ThreadTest  
  6. {  
  7.     public static void main(String[] args)  
  8.     {  
  9.         //用匿名内部类创建多线程对象   
  10.         new Thread()  
  11.         {  
  12.             public void run()  
  13.             {  
  14.                 for(int x = 0; x<10;x++)  
  15.                 {  
  16.                     System.out.println(Thread.currentThread().getName()+"...."+x);  
  17.                 }  
  18.             }  
  19.         }.start();  
  20.   
  21.         //用实现Runnable接口方式，创建线程  
  22.         Runnable r = new Runnable()  
  23.         {  
  24.             public void run()  
  25.             {  
  26.                 for(int x = 0; x<10;x++)  
  27.                 {  
  28.                     System.out.println(Thread.currentThread().getName()+"...."+x);  
  29.                 }  
  30.             }  
  31.         };  
  32.         //创建线程，接收对象并运行   
  33.         new Thread(r).start();  
  34.   
  35.         for(int x = 0; x<10;x++)  
  36.         {  
  37.             System.out.println(Thread.currentThread().getName()+"...."+x);  
  38.         }  
  39.     }  
  40. }  
/*
多线程的小事例:
当某些线程需要同时运行时，就将其单独封装，用多线程运行。
*/
class ThreadTest
{
	public static void main(String[] args)
	{
		//用匿名内部类创建多线程对象
		new Thread()
		{
			public void run()
			{
				for(int x = 0; x<10;x++)
				{
					System.out.println(Thread.currentThread().getName()+"...."+x);
				}
			}
		}.start();

		//用实现Runnable接口方式，创建线程
		Runnable r = new Runnable()
		{
			public void run()
			{
				for(int x = 0; x<10;x++)
				{
					System.out.println(Thread.currentThread().getName()+"...."+x);
				}
			}
		};
		//创建线程，接收对象并运行
		new Thread(r).start();

		for(int x = 0; x<10;x++)
		{
			System.out.println(Thread.currentThread().getName()+"...."+x);
		}
	}
}
输出结果：

mh2015cool
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
多线程高新(黑马程序员)
04-03
NULL 博文链接：https://lvwenwen.iteye.com/blog/1470696
悲观锁和乐观锁
weixin_41359780的博客
06-29 132
悲观锁和乐观锁 悲观锁 总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁。 常用的就是代码块或方法前加synchronized关键字和ReentrantLock。 synchronized自动解锁，Lock需求手动解锁，并且必须在finally中释放，否则会引起死锁。 乐观锁 总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据。 常用的方法就是Ver
day14-多线程01
weixin_48048140的博客
07-21 214
1.实现多线程 1.1简单了解多线程【理解】 是指从软件或者硬件上实现多个线程并发执行的技术。 具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。 1.2并发和并行【理解】 并行：在同一时刻，有多个指令在多个CPU上同时执行。 并发：在同一时刻，有多个指令在单个CPU上交替执行。 1.3进程和线程【理解】 进程：是正在运行的程序 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态
黑马程序员--多线程
Ob_ject的博客
11-05 403
一、定义 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径或叫控制单元。 线程（FlashGet）：进程中的一个独立的控制单元。线程在控制着进程的执行。  一个进程中至少有一个线程。 二、多线程作用 优点：多任务共同进行，防止后任务在一定时间内执行不到的问题发生。 弊端：线程如果太多，会导致效率降低。 多线程内部执行方式： 1、多线程运行结果的随机
26_多线程_第26天（Thread、线程创建、线程池）_讲义
小强博客
12-03 355
今日内容介绍 1、多线程 2、线程池 01进程概念 A:进程概念 a:进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行， 即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。 02线程的概念 A:线程的概念 a:线程：线程是进程中的一个执行单元(执行路径)，负责当前进程中程序的执行， 一个进程中至少有一个线程。一个进程中是可以有多个线程的， 这个应用程序也可以称之为多线...
黑马程序员–Java多线程讲解笔记
12-22
当一个进程中线程有多个时，是多线程。 　为什么要用多线程 　1，让计算机"同时"做多件事情，节约时间。 　2，后台运行程序，提高程序的运行效率.。 　3，多线程可以让程序"同时"处理多个事情。 　4，...
iOS高级程序员进阶——多线程编程核心技术模式篇
06-18
多线程是一种软件实现多个线程并发执行任务的技术。在iOS开发中，实现多线程的的方式有很多种，常用的有pthread、NSThread、GCD与NSOperation。在实际应用中，多线程技术也有着非常多的使用场景，比如异步的网络请求...
黑马程序员-java多线程技术01
03-25
NULL 博文链接：https://huangminwen.iteye.com/blog/1157983
黑马程序员——多线程（上）
sinat_31516053的博客
10-13 330
多线程——线程相关概念 基本概念 线程：是依赖于进程的执行绪（执行路径/控制单元），是程序使用CPU的基本单位。 进程：当前正在执行的程序，代表一个应用程序在内存中的执行区域。 多进程：同一时间段内执行多个任务。同一时刻只能执行一个任务。如Windows为代表的操作系统。 多进程并不提高某个程序的执行速度，仅仅是提高了CPU的使用率。真正的多进程执行是指多核同时计算。 单线
黑马程序员——多线程8：其他线程工具—上
axr1985lazy的专栏
09-02 561
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1  传统定时器技术 1.1  定时器技术简介         定时器，顾名思义就是到达既定时间以后开始执行预先定义的任务的一种工具。由于利用这一工具执行操作时，底层会默认地开启一个单独的线程，因此也是一种多线程技术。那么定时器技术在实际开发中，尤其是在游戏开发中十分常见的，比如俄罗斯
黑马程序员-【多线程】
Hello World
05-15 621
一、什么是多线程 进程：是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。 线程：是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程，它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。     多线程是这样一种机制，它允许在程序中并发执行多个指令流，每
黑马程序员多线程视频总结
fordushao的博客
12-24 836
线程池的工作模型主要两部分组成，一部分是运行Runnable的Thread对象，另一部分就是阻塞队列。由线程池创建的Thread对象其内部的run方法会通过阻塞队列的take方法获取一个Runnable对象，然后执行这个Runnable对象的run方法（即，在Thread的run方法中调用Runnable对象的run方法）。当Runnable对象的run方法执行完毕以后，Thread中的run方法又
黑马程序员-多线程
Zhaoss_的博客
04-30 396
多线程的理解： 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的实体，一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行. 一个程序至少有一个进程,一个进程至少有一个线程；每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多
“黑马程序员”多线程
之火一天的独立专栏
05-30 139
   android培训    java培训期待与您交流!!! 本篇主要介绍多线程技术   下面是关于线程安全问题的实例代码1 class Ticket implements Runnable { private int num = 100; Object obj = new Object(); public void run() { while(true) ...
黑马程序员多线程练习题
最新发布
08-23
黑马程序员多线程练习题主要包括两个问题。第一个问题是如何控制四个线程在打印log之前能够同时开始等待1秒钟。一种解决思路是在线程的run方法中调用parseLog方法，并使用Thread.sleep方法让线程等待1秒钟。另一种解决思路是使用线程池，将线程数量固定为4个，并将每个调用parseLog方法的语句封装为一个Runnable对象，然后提交到线程池中。这样可以实现一秒钟打印4行日志，4秒钟打印16条日志的需求。 第二个问题是如何修改代码，使得几个线程调用TestDo.doSome(key, value)方法时，如果传递进去的key相等（equals比较为true），则这几个线程应互斥排队输出结果。一种解决方法是使用synchronized关键字来实现线程的互斥排队输出。通过给TestDo.doSome方法添加synchronized关键字，可以确保同一时间只有一个线程能够执行该方法，从而实现线程的互斥输出。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [黑马程序员——多线程10：多线程相关练习](https://blog.csdn.net/axr1985lazy/article/details/48186039)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值