黑马程序员：多线程

最新推荐文章于 2014-07-10 16:58:11 发布

xuan2211

最新推荐文章于 2014-07-10 16:58:11 发布

阅读量475

点赞数

本文链接：https://blog.csdn.net/u011373068/article/details/17332521

版权

------- android培训、java培训、期待与您交流！ ----------

Java 的一大特点就是内置对多线程的支持。

一、Java中的线程

1、进程与线程

进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的执行单位。一个进程在执行过程中可以产生多个线程，形成多条执行线索，每条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。

每个Java程序都有一个默认的主线程。Java应用程序总是从主类的main方法开始执行。当JVM加载代码，发现main方法之后，就会启动一个线程，这个线程称作“主线程”，该线程负责执行main方法。在main方法中再创建的线程，就称为程序中的其他线程。如果main方法没有再创建其他线程，那么当main方法执行完最后一条语句，即main方法返回时，JVM就会结束Java应用程序。

2、线程的状态与生命周期

Java使用Thread类及其子类的对象来表示线程，新建的线程在他的一个完整的生命周期中通常要经历4种状态。

1）新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。此时它已经有了相应的内存空间和其他资源。

2）运行

线程创建之后就具备了运行的条件，一旦轮到它来享用CPU资源时，即JVM将CPU的使用权切换给该线程时，此线程就可以脱离创建它的主线程，独立开始自己的生命周期。

线程被创建后仅仅是占有了内存资源，在JVM管理的线程中还没有这个线程，此线程必须调用start()方法（从父类中继承的方法）通知JVM，这样JVM就会知道又有一个新线程排队等候切换了。

当JVM将CPU的使用权切换给线程时，如果线程是Thread的子类创建的，该类中的run()方法就立刻执行。所以必须在子类中重写父类的run()方法，Thread类中的run()方法没有具体内容，程序要在Thread类的子类中重写run()方法来覆盖父类中的run()方法，run()方法规定该线程的具体使命。

3）中断

（1）JVM将CPU资源从当前线程切换给其他线程，使本线程让出CPU的使用权处于中断状态。

（2）线程使用CPU资源期间，执行了 sleep（int millsecond）方法，使当前线程进入休眠状态。sleep方法是Thread类中的一个方法，线程一旦执行了sleep方法，就立刻让出CPU的使用权，使当前线程处于中断状态。经过参数 millsecond指定的毫秒数之后，该线程就重新进入到线程队列中排队等待CPU资源，以便从终端处继续运行。

（3）线程使用CPU资源期间，执行了wait()方法，使当前线程进入到等待状态，等待状态的线程不会主动进入到线程队列中排队等待CPU资源，必须由其他线程调用notify()方法通知它，使得它重新进入到线程排队中等待CPU资源，以便从中断处继续运行。

（4）线程使用CPU资源期间，执行某个操作进入阻塞状态，比如执行读/写操作引起阻塞。进入阻塞状态时线程不能进入排队队列，自由当引起阻塞的原因消除后，线程才重新进入到线程队列中排队等待CPU资源，以便从原来的中断处继续运行。

4）死亡

处于死亡状态的线程不具备运行的能力。线程死亡的原因有两个：一个是正常运行的线程完成了它的全部工作，即执行完run()方法中的全部语句，结束了run()方法；另一个原因是线程被提前强制终止，即强制run()方法结束。所谓死亡状态就是线程释放了实体，即释放分配给线程对象的内存。

3、创建线程

一种方法是继承Thread类或其子类。

步骤：

1）定义类继承Thread类。

2）复写Thread类中的run()方法。用于运行自定义代码。

3）调用线程的start方法。该方法的作用：启动线程，调用run方法。

例：
package cn.itcast;
/**
 *
 * @author wangxuan
 *
 */
//创建一个类继承Thread

class Demo extends Thread{
//复写run方法
	public void run() {
		for (int i = 0;	 i < 60; i++) {
			System.out.println("demo"+i);
		}
		
	}
	
}

public class ThreadDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Demo demo = new Demo();
		//调用start方法
		demo.start();
	}

}
第二种是实现Runnable接口。
步骤：

1）定义类实现Runnable接口。

2）覆盖Runnable接口中的run方法。

将线程要运行的代码放到run方法中。

3）通过Thread创建线程对象

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

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

5）调用Thread类的start方法开启线程，并调用Runnable接口中的run方法。

例：
package cn.itcast;

class Run implements Runnable
{
	private int a = 100;
		public void run() {
			// TODO Auto-generated method stub
			while (true) {
			if (a>0) {
				System.out.println("hahha"+a);
				a--;
				
			} 
			}
			
		}
}

public class RunnableDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Run demo = new Run();
		Thread t1 = new Thread(demo);
		Thread t2 = new Thread(demo);
		Thread t3 = new Thread(demo);
		Thread t4 = new Thread(demo);
		t1.start();
		t2.start();
		t3.start();
		t4.start();

	}

}
实现方式和继承方式有什么区别？
实现方式的好处：避免了单继承的局限性。

在定义线程时，建议使用实现方式。

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

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

3、线程的同步：
java可以创建多个线程，在处理多线程问题时，必须注意这样一个问题：当两个或多个线程同时访问同一个变量，并且一个线程需要修改这个变量，则有可能发生混乱。此时我们就要用线程的同步来处理这种问题。

一个方法是使用关键字synchronized修饰后，当一个线程A使用这个方法时，其他方法使用这个方法就必须等待，直到线程A使用完该方法。

所谓的线程同步就是若干个线程都需要使用一个synchronized修饰方法。

同步的前提：

1）必须保证至少有两个线程。

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

必须保证线程中，只有一个同步在运行。

用法：
synchronized (obj) {
					//要同步的代码
					
				}
用于synchronized的obj叫lock旗标(锁旗标)，可以是任何对象，我们通常称之为同步对象或者监视器对象。
同步中的 wait()、notify()、notifyAll()方法：

wait：释放资源、释放锁。

notity：唤醒灯带池中的第一个等待的线程。

notifyAll：唤醒等待池中所有的线程。

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

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

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