黑马程序员-java多线程

最新推荐文章于 2022-10-17 17:18:37 发布

被驯服的象

最新推荐文章于 2022-10-17 17:18:37 发布

阅读量520

点赞数

分类专栏： Java基础文章标签： java 多线程

本文链接：https://blog.csdn.net/ddesyt/article/details/34105981

版权

Java基础专栏收录该内容

27 篇文章 0 订阅

订阅专栏

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

多线程概述：

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

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

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

例如，JVM启动时会有一个进程java.exe。该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中。该线程称之为主线程。JVM启动了不止一个线程，还包括负责垃圾回收机制的线程等。

多线程的意义：

使多部分代码同时执行；下载时加快速度等。

线程的几种状态：

创建线程方法：

方法一：继承Thread类

方法二：实现Runnable接口

例1：

/**
*简单的卖票程序，利用多线程实现多个窗口同时卖票
*/
//方法一：继承Thread类
class MyThread extends Thread
{
	private static int count=20;
	public void run()
	{
		while(true)
		{
				if (count>0)
					System.out.println(Thread.currentThread().getName()+"..."+count--);
				else break;
		}
	}
}
/*
//方法二：实现Runnable接口
class Ticket implements Runnable
{
	private int count=20;
	public void run()
	{
		while(true)
		{		
				if(count>0)
					System.out.println(Thread.currentThread().getName()+"..."+count--);
				else break;
		}
	}
}
*/
class ThreadTest
{
	public static void main(String[] args)
	{
		Thread t1=new MyThread();
		Thread t2=new MyThread();
		t1.start();               //启动线程
		t2.start();
		/*
		Ticket ticket=new Ticket();
		Thread t3=new Thread(ticket);
		Thread t4=new Thread(ticket);
		*/
	}
}

输出结果：

Thread-0...20
Thread-0...18
Thread-1...19
Thread-0...17
Thread-1...16
Thread-0...15
Thread-1...14
Thread-0...13
Thread-1...12
Thread-0...11
Thread-1...10
Thread-0...9
Thread-1...8
Thread-0...7
Thread-1...6
Thread-0...5
Thread-1...4
Thread-0...3
Thread-1...2
Thread-0...1

此例中，发现运行结果每一次都不同。因为在某一时刻，只能有一个程序在运行（多核CPU除外） 。CPU在做着快速的切换，以达到看上去是同时运行的效果。多个线程都在竞争CPU的执行权，CPU执行到谁，谁就运行。因此打印结果并不固定。

两种方法的区别：

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

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

实现Runnable接口方法，避免了单继承的局限性。在创建线程时，建议使用实现的方式。

获取线程对象及名称：

线程都有自己默认的名称：Thread-编号，编号从0开始。

static Thread currentThread()：获取当前线程对象

getName()：获取线程名称

setName()或构造函数：设置线程名称

例2：

/**
*简单的卖票程序
*/
class MyThread extends Thread
{
	private static int x;
	MyThread(String name)
	{
		super(name);
	}
	public void run()
	{
		for (x=0;x<10 ;x++ )
		{
			System.out.println((Thread.currentThread()==this)+"..."+this.getName()+"run..."+x);
		}
		
	}
}
class ThreadTest
{
	public static void main(String[] args)
	{
		Thread t1=new MyThread("线程A");
		Thread t2=new MyThread("线程B");
		t1.start();              
		t2.start();
	}
}

输出结果：

true...线程Arun...0
true...线程Arun...1
true...线程Brun...0
true...线程Arun...2
true...线程Brun...3
true...线程Arun...4
true...线程Brun...5
true...线程Arun...6
true...线程Brun...7
true...线程Arun...8
true...线程Brun...9

此例中，我们发现0被打印了两次，因此我们得知多线程运行出现了安全问题。为了解决此问题，需要了解多线程的同步知识。

多线程的安全问题：

例3：

/**
*简单的卖票程序，利用多线程实现多个窗口同时卖票
*/
class Ticket implements Runnable
{
	private int count=20;
	public void run()
	{
		while(true)
		{		
				if(count>0)
				{
					try{Thread.sleep(10);}catch(Exception e){}
					System.out.println(Thread.currentThread().getName()+"...sale"+count--);
				}	
				else break;
		}
	}
}
class ThreadTest
{
	public static void main(String[] args)
	{
		Ticket ticket=new Ticket();
		Thread t3=new Thread(ticket);
		Thread t4=new Thread(ticket);
		t3.start();
		t4.start();
	}
}

输出结果：

Thread-0...sale20
Thread-1...sale19
Thread-1...sale18
Thread-0...sale17
Thread-0...sale16
Thread-1...sale15
Thread-1...sale14
Thread-0...sale13
Thread-1...sale12
Thread-0...sale11
Thread-0...sale10
Thread-1...sale9
Thread-0...sale8
Thread-1...sale7
Thread-0...sale6
Thread-1...sale5
Thread-0...sale4
Thread-1...sale3
Thread-0...sale2
Thread-1...sale1
Thread-0...sale0

此例中，Thread-0售出了第0张票，而这是错票。与例2一样，多线程的运行出现了安全问题。

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

解决办法：对多条操作共性数据的语句，只让一个线程执行完。在执行过程中，其他线程不可以参与执行。

java对于多线程的安全问题提供了专业的解决方式：同步代码块或同步函数

同步代码块：

synchronized(对象)
{
    需要被同步的代码
}

同步函数：

[访问修饰符] synchronized [返回值类型] function(参数列表){}

同步的意义：

对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使获取CPU的执行权，也进不去，因为没有获取锁。

使用同步时的注意事项：

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

2、明确共享数据；

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

总而言之，只需要同步需要同步的语句。
例4：利用同步代码块解决例3中暴露的安全问题

/**
*简单的卖票程序，利用多线程实现多个窗口同时卖票
*/
class Ticket implements Runnable
{
	private int count=20;//不用static
	Object obj=new Object();
	public void run()
	{
		while(true)
		{
			synchronized(obj)         //同步代码块，同步操作共享数据的语句
			{
				if(count>0)
				{
					try{Thread.sleep(10);}catch(Exception e){}
					System.out.println(Thread.currentThread().getName()+"..."+count--);
				}
				else break;
			}
		}
	}
}

输出结果：

Thread-0...20
Thread-0...19
Thread-0...18
Thread-0...17
Thread-0...16
Thread-0...15
Thread-0...14
Thread-0...13
Thread-0...12
Thread-0...11
Thread-0...10
Thread-1...9
Thread-1...8
Thread-1...7
Thread-1...6
Thread-1...5
Thread-1...4
Thread-1...3
Thread-1...2
Thread-1...1

同步函数使用的锁是this：

同步函数用的是哪一个锁那？函数需要被对象调用，那么函数都有一个所属对象引用，就是this。所以同步函数使用的锁是this。

我们通过例5来进行验证。

例5：

/**
*使用两个线程来卖票，一个线程在同步代码块中，一个线程在同步函数中，都在执行卖票动作
*/
class Ticket implements Runnable
{
	private int count=100;//不用static
	boolean flag=true;
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(this)         //同步代码块以this为锁
				{
					if(count>0)
					{
						try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+"...code..."+count--);
					}
					else break;
				}
			}
		}
		else
			while(true)
				show();
	}
	public synchronized void show()
	{
		if(count>0)
		{
			try{Thread.sleep(10);}catch(Exception e){}
						System.out.println(Thread.currentThread().getName()+"...show..."+count--);
		}
		
	}
}
class ThreadTest
{
	public static void main(String[] args)
	{
		Ticket ticket=new Ticket();
		Thread t3=new Thread(ticket);
		Thread t4=new Thread(ticket);
		t3.start();
		try{Thread.sleep(10);}catch(Exception e){}
		ticket.flag=false;
		t4.start();
	}
}

打印结果过长，请读者自己验证。此例结果显示，多线程未出现安全问题，说明同步成功，证明了同步函数的锁是this。

静态同步函数的锁是Class对象：

如果同步函数被静态修饰后，使用的锁是什么呢？

通过类似例5的验证，发现不是this，因为静态方法中不可以定义this。类进入内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象，即类名.class。

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

死锁：

同步中嵌套同步。当两个线程被阻塞，每个线程在等待另一个线程时就发生死锁。如例6，

例6：

/**
*使用两个线程来卖票，一个线程在同步代码块中，一个线程在同步函数中，都在执行卖票动作
*/
class Ticket implements Runnable
{
	private int count=100;//不用static
	Object obj=new Object();
	boolean flag=true;
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(obj)         //同步代码块以this为锁
				{
					show();
				}
			}
		}
		else
			while(true)
				show();
	}
	public synchronized void show()
	{
		synchronized(obj)
		{
			if(count>0)
			{
				try{Thread.sleep(10);}catch(Exception e){}
							System.out.println(Thread.currentThread().getName()+"...show..."+count--);
			}
		}
	}
}
class ThreadTest
{
	public static void main(String[] args)
	{
		Ticket ticket=new Ticket();
		Thread t3=new Thread(ticket);
		Thread t4=new Thread(ticket);
		t3.start();
		try{Thread.sleep(10);}catch(Exception e){}
		ticket.flag=false;
		t4.start();
	}
}

线程间通信：

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

例7：

//线程间通讯，输入与输出案例
class Resource
{
	public boolean flag=false;
	public String name;
	public String sex;
}
class Input implements Runnable
{
	private Resource r;
	Input(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		int x=0;
		while (true)
		{
			synchronized(r)
			{
				if(x==0)
				{
					r.name="AAA";
					r.sex="male";
				}
				else
				{
					r.name="BBB";
					r.sex="female";
				}
				x=(x+1)%2;
			}
		}
	}
}
class Output implements Runnable
{
	private Resource r;
	Output(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			synchronized(r)
			{
				System.out.println(r.name+"...."+r.sex);
			}
		}
	}
}
class ThreadTest
{
	public static void main(String[] args)
	{
		Resource r=new Resource();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
		
	}
}

输出结果：

BBB....female
BBB....female
BBB....female
BBB....female
BBB....female
BBB....female
AAA....male
AAA....male
AAA....male

由于例7中，未设置跳出循环语句，所以结果将不断打印下去。这里只是截取了开头部分。由此我们可以发现，虽然同步代码块解决了输入、输出同时进行造成的安全隐患，但是仍存在连续输入或连续输出的情况，而我们希望输入、输出依次进行。而这需要引入等待唤醒机制。

等待唤醒机制需要从java.lang.Object的类的三个方法来学习：

void notify()：唤醒在此对象监视器上等待的单个线程。

void notifyAll()：唤醒在此对象监视器上等待的所有线程。

void wait()：导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法。

例8：

//线程间通讯，输入与输出案例
//通过等待唤醒机制，使输入、输出依次进行
class Resource
{
	public boolean flag=false;
	public String name;
	public String sex;
}
class Input implements Runnable
{
	private Resource r;
	Input(Resource 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="AAA";
					r.sex="male";
				}
				else
				{
					r.name="BBB";
					r.sex="female";
				}
				x=(x+1)%2;
				r.flag=true;
				r.notify();  //唤醒监视器中等待的线程
			}
		}
	}
}
class Output implements Runnable
{
	private Resource r;
	Output(Resource 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 ThreadTest
{
	public static void main(String[] args)
	{
		Resource r=new Resource();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
		
	}
}

输出结果：

AAA....male
BBB....female
AAA....male
BBB....female
AAA....male
BBB....female
AAA....male
BBB....female
AAA....male
BBB....female
AAA....male
BBB....female
AAA....male
BBB....female
AAA....male
BBB....female
AAA....male
BBB....female

由于例8中，未设置跳出循环语句，所以结果将不断打印下去。这里只是截取了开头部分。

由结果可知，等待唤醒机制的引入很好的解决了例7的问题。

例9：代码优化

//输入、输出案例的优化
class Resource 
{
	private boolean flag=false;
	private String name;
	private String sex;
	public synchronized void setR(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 getR()
	{
		if(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(name+"..."+sex);
		flag=false;
		this.notify();
	}
}
class Input implements Runnable
{
	private Resource r;
	Input(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		int x=0;
		while(true)
		{
			if(x==0)
				r.setR("AAA","male");
			else
				r.setR("BBB","female");
			x=(1+x)%2;
		}
	}
}
class Output implements Runnable
{
	private Resource r;
	Output(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while (true)
		{
			r.getR();
		}
	}
}
class ThreadTest
{
	public static void main(String[] args)
	{
		Resource r=new Resource();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();	
	}
}

例10：生成者与消费者案例

class Resource 
{
	private boolean flag=false;
	private String name;
	public synchronized void setR(String name)
	{
		if(flag)
			try{this.wait();}catch(Exception e){}
		this.name=name;
		System.out.println(Thread.currentThread().getName()+"输入..."+this.name);
		flag=true;
		this.notify();
	}
	public synchronized void getR()
	{
		if(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"输出..."+this.name);
		flag=false;
		this.notify();
	}
}
class Input implements Runnable
{
	private Resource r;
	Input(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			r.setR("商品");
		}
	}
}
class Output implements Runnable
{
	private Resource r;
	Output(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while (true)
		{
			r.getR();
		}
	}
}
class ThreadTest
{
	public static void main(String[] args)
	{
		Resource r=new Resource();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();	
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();	
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();	
	}
}

输出结果：

Thread-0输入...商品
Thread-1输出...商品
Thread-0输入...商品
Thread-1输出...商品
Thread-0输入...商品
Thread-2输入...商品
Thread-1输出...商品
Thread-0输入...商品
Thread-3输出...商品
Thread-2输入...商品
Thread-0输入...商品
Thread-3输出...商品
Thread-2输入...商品
Thread-5输出...商品
Thread-0输入...商品

由于例10中，未设置跳出循环语句，所以结果将不断打印下去。这里只是截取了开头部分。

由结果可知，当输入、输出线程分别多个时，无法保证输入、输出依次进行。

解决办法：把用if语句来判断标记，改为用while语句判断标记。

例11：

将例10中setR()、getR()方法修改如下：

	public synchronized void setR(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}
		this.name=name;
		System.out.println(Thread.currentThread().getName()+"输入..."+this.name);
		flag=true;
		this.notify();
	}
	public synchronized void getR()
	{
		while(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"输出..."+this.name);
		flag=false;
		this.notify();
	}

输出结果：

发现程序会陷入等待。因为只用notify()，容易只唤醒本方线程的情况，导致程序中的所有线程都等待。

解决办法：将notify()方法改为notifyAll()方法。

例12：

将例10中setR()、getR()方法修改如下：

	public synchronized void setR(String name)
	{
		while(flag)
			try{this.wait();}catch(Exception e){}
		this.name=name;
		System.out.println(Thread.currentThread().getName()+"输入..."+this.name);
		flag=true;
		this.notifyAll();
	}
	public synchronized void getR()
	{
		while(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"输出..."+this.name);
		flag=false;
		this.notifyAll();
	}

输出结果：

Thread-0输入...商品
Thread-1输出...商品
Thread-0输入...商品
Thread-1输出...商品
Thread-0输入...商品
Thread-1输出...商品
Thread-0输入...商品
Thread-1输出...商品
Thread-0输入...商品
Thread-3输出...商品

由于例12中，未设置跳出循环语句，所以结果将不断打印下去。这里只是截取了开头部分。

由结果可知，例12很好的解决了例10的问题。

java1.5升级后的新特性：

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

将同步synchronized替换成现实Lock操作；将对象锁替换成Condition对象，它可以通过Lock锁获得；将对象锁的wait()、notify()、notifyAll()方法替换成Condition对象的await()、signal()、signalAll()方法。

在例13中，实现本方只唤醒对方的操作，

例13：多线程升级解决方案

import java.util.concurrent.locks.*;
class Resource 
{
	private boolean flag=false;
	private String name;
	private Lock lock=new ReentrantLock();              //获取Lock对象
	private Condition condition_pro=lock.newCondition();//获取生产者condition
	private Condition condition_con=lock.newCondition();//获取消费者condition
	public void setR(String name)throws InterruptedException
	{
		lock.lock();
		try
		{
			while(flag)
				condition_pro.await();	
			this.name=name;
			System.out.println(Thread.currentThread().getName()+"输入..."+this.name);
			flag=true;
			condition_con.signal();
		}
		finally
		{
			lock.unlock();
		}		
	}
	public void getR()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 Input implements Runnable
{
	private Resource r;
	Input(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				r.setR("商品");
			}
			catch (Exception e)
			{
			}
			
		}
	}
}
class Output implements Runnable
{
	private Resource r;
	Output(Resource r)
	{
		this.r=r;
	}
	public void run()
	{
		while (true)
		{
			try
			{
				r.getR();
			}
			catch (Exception e)
			{
			}	
		}
	}
}
class ThreadTest
{
	public static void main(String[] args)
	{
		Resource r=new Resource();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();	
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();	
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();	
	}
}

用升级解决方案重写例12，效果相同。

停止线程：

stop()方法已经过时，那么如何停止线程？

只有一种，那就是run()方法结束。开启多线程运行，运行代码通常是循环结构，因此只要控制住循环，就可以让run()方法结束，也就是线程停止。

例14：

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 ThreadTest
{
	public static void main(String[] args)
	{
		StopThread st=new StopThread();
		Thread t1=new Thread(st);
		t1.start();
		int num=0;
		while (true)
		{
			if (num++==10)
			{
				st.changeFlag();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"..."+num);
		}
		System.out.println("OVER!");
	}
}

输出结果：

main...1
Thread-0...run
Thread-0...run
main...2
Thread-0...run
main...3
Thread-0...run
main...4
Thread-0...run
main...5
Thread-0...run
main...6
Thread-0...run
main...7
main...8
main...9
Thread-0...run
main...10
Thread-0...run
OVER!

由结果可知，线程t1可以结束。

特殊情况：

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

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

例14：

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 ThreadTest
{
	public static void main(String[] args)
	{
		StopThread st=new StopThread();
		Thread t1=new Thread(st);
		t1.start();
		int num=0;
		while (true)
		{
			if (num++==10)
			{
				t1.interrupt();//强制让线程t1恢复到运行状态中
				break;
			}
			System.out.println(Thread.currentThread().getName()+"..."+num);
		}
		System.out.println("OVER!");
	}
}

输出结果：

main...1
main...2
main...3
main...4
main...5
main...6
main...7
main...8
main...9
main...10
OVER!
Thread-0...Exception
Thread-0...run

守护线程：

即后台线程，前台线程结束后，后台自动结束。

setDaemon()：将线程设置为守护线程。

线程调度：

join()方法：

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

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

例15：

public static void main(String[] args)
	{
		Demo d=new Demo();
		Thread t1=new Thread(d);
		Thread t2=new Thread(d);
		t1.start();
		t2.start();
		t1.join();
		System.out.println("OVER!");
	}

当main方法执行到t1.join()时，main方法就会等待，直到t1线程执行完，main方法才会继续执行，打印“OVER”。

yield()方法：

临时释放线程执行权，减缓线程执行频率。

优先级：

默认为5，常用1，5，10。

setPriority()：设定线程的优先级。

MAX_PRIORITY=10;MIN_PRIORITY=1;NORM_PRIORITY=5;

开发常见写法：

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()+"Thread..."+x);
				}
			}
		}.start();

		for (int x=0;x<10 ;x++ )
		{
			System.out.println(Thread.currentThread().getName()+"main..."+x);
		}

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

延伸阅读：

java多线程编程总结

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com