Java多线程编程— 概念以及经常使用控制

　　多线程能满足程序猿编写很有效率的程序来达到充分利用CPU的目的，由于CPU的空暇时间可以保持在最低限度。有效利用多线程的关键是理解程序是并发运行而不是串行运行的。比如：程序中有两个子系统须要并发运行，这时候就须要利用多线程编程。

线程的运行中须要使用计算机的内存资源和CPU。

一、    进程与线程的概念

　　这两者的概念，这里仅仅给出自己狭隘的理解：

　　进程：进程是一个独立的活动的实体，是系统资源分配的基本单元。

它能够申请和拥有系统资源。

每一个进程都具有独立的代码和数据空间（进程上下文）。

进程的切换会有较大的开销。

　　进程，是一个“执行中的程序”。

程序是一个静态的没有生命的实体，仅仅有处理器赋予程序生命时（操作系统执行之），它才干成为一个活动的实体。我们称其为进程。

也就是说。进程是正在执行的程序的实例（an instance of a computer program that is being executed）。比如，你执行一个qq。就会启动一个进程，再次执行qq。就会再启动一个进程。

　　

　　线程： 事实上，60年代，进程不仅是资源分配的基本单元。还是资源调度的基本单元。然而随着计算机技术的发展，进程出现了非常多弊端，一是因为进程是资源拥有者。创建、撤消与切换存在较大的时空开销，因此须要引入轻型进程。二是因为对称多处理机（SMP）出现，能够满足多个执行单位，而多个进程并行开销过大。

因此在80年代，出现了能独立执行的基本单位——线程（Threads）。

也就是说，如今。线程才是资源（cpu）调度的基本单元，它是一个程序内部的控制流程。线程是进程内部的更小的单元。它基本不占用系统资源。一个进程内的多个线程是为了协同工作来处理一件事情。

　　

简单总结来说就是。进程是为了分配得到资源，然后由它里面的线程利用资源来处理事情。

进程是一个壳子，实际干事的都是线程。

（比如，我们的main函数作为主线程）。

二者较为深入一点的总结：http://wangzhipeng0713.blog.163.com/blog/static/1944751652015522359459/

二、    线程的创建和启动

　　2.1   方式一：线程类实现Runnable接口

　　定义线程类：

/**
 * 定义线程类（实现Runnable接口）
 *
 * @author wangzhipeng
 *
 */
public class Runner1 implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("New Thread Runner1-->" + i);
		}
	}
}

　　測试类：

public class TestThread1 {
	// 1、main方法为主线程
	public static void main(String[] args) {
		// 2、启动第二个线程
		Runner1 runner1 = new Runner1();
		Thread thread = new Thread(runner1, "zhipeng");// 注意，Runner类实现了Runnable接口，启动线程时须要用一个Thread类将其包起来
		thread.start();// 调用start方法。使得线程进入“就绪”状态

		for (int i = 0; i < 100; i++) {
			System.out.println("【Main】 Thread-->" + i);
		}
	}
}

　　执行结果：

　　2.2  方式二：线程类继承Thread类并重写其run方法

　　定义线程类：

/**
 * 定义线程类（继承Thread类）
 *
 * @author wangzhipeng
 *
 */
public class Runner2 extends Thread {

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println("New Thread Runner1-->" + i);
		}
	}
}

　　測试类：

public class TestThread2 {

	// main方法为主线程
	public static void main(String[] args) {
		// 1、线程类继承Thread类的start写法
		Runner2 runner2 = new Runner2();
		runner2.start();// 这里须要注意：由于Runner2已经是一个线程类了，所以不须要再对它进行包装，直接调用start就可以

		// 2、线程类实现Runnable接口的start写法（须要用Thread类包装）
		// Thread thread = new Thread(runner1);
		// thread.start();

		for (int i = 0; i < 100; i++) {
			System.out.println("【Main】 Thread-->" + i);
		}
	}

}

　　执行结果：

　　2.3  小结

　　尽管两种方式都能达到同样的效果，但我们一般不採用继承的方式实现多线程。由于一旦继承了Thread类，你的类就无法再继承其他的类。而实现了Runnable接口后。你还能够实现其他接口或继承其他类。也就是说面向接口编程比較灵活。

三、    线程的状态转换

　　这里须要注意的是，线程调用start()方法后，是进入“就绪状态”，而不是“执行状态”。

也就是说，是线程告诉操作系统，我已准被调度所须要的一切事物，仅仅有在被调度后线程才进入到执行状态。

四、    线程控制的基本方法

　　这里主要简介sleep/join/yield/以及线程的优先级。至于wait与notify/notifyAll这一对重要的方法会在后面一篇文章。线程同步问题中具体介绍。

　　4.1  sleep方法

　　非常easy非经常常使用，是Thread类的静态方法：

　　演示样例程序

　　线程类：

import java.util.Date;

/**
 * 通过继承Thread类实现线程类
 *
 * @author wangzhipeng
 *
 */
public class MyThread extends Thread {
	public void run() {
		/**
		 * 每一秒钟输出一下当前日期
		 */
		while (true) {
			System.out.println("---->" + new Date());
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				return;
			}
		}
	}
}

　　Sleep測试类：

public class TestInterrupt {
	public static void main(String[] argStrings) {
		MyThread myThread = new MyThread();
		myThread.start();// 启动第二个线程
		try {
			Thread.sleep(5000);// 主线程5秒钟后终止第二个线程
			myThread.interrupt();// 一般不用这样的方式终止线程--比較粗暴
			// myThread.stop();//更加不用--更加粗暴
		} catch (InterruptedException e) {
			return;
		}
	}
}

　　这里须要注意“终止线程”的方式，上面提到了interrupt()与stop()两种方式都是比較粗暴的方式，即强行终止，一般不採用。

而是在线程类中定义一个信号量。然后client通过给该信号量赋值来“温柔”地控制线程的终止。比如给以下的线程类中的flag赋值false就可以终止线程。

public class MyThread extends Thread {
	boolean flag = true;// 定义信号量来控制线程的终止

	public void run() {
		/**
		 * 每一秒钟输出一下当前日期
		 */
		while (flag) {
			System.out.println("---->" + new Date());
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				return;
			}
		}
	}
}

　　4.2  join方法

　　join()代表将第二线程合并到主线程，也就是将第二线程与主线程顺序运行，而不是并发运行。

　　join(5000) 代表前5秒钟将第二线程合并到主线程，5秒过后。第二线程与主线程并发运行。

　　演示样例程序

　　线程类：

/**
 * 定义线程类（继承Thread类）
 *
 * @author wangzhipeng
 *
 */
public class Mythread2 extends Thread {
	Mythread2(String s) {
		super(s);
	}

	/**
	 * 每一秒钟输出一下当前线程的名称
	 */
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("I am " + getName());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				return;
			}
		}

	}
}

　　join方法測试类：

/**
 * join方法測试
 *
 * @author wangzhipeng
 *
 */
public class TestJoin {

	public static void main(String[] args) {
		Mythread2 mythread2 = new Mythread2("zhpeng");
		mythread2.start();// 启动第二线程
		try {
			mythread2.join();// 将第二线程合并到主线程，也就是将第二线程与主线程顺序运行。而不是并发运行
			// mythread2.join(5000);// 前5秒钟将第二线程合并到主线程，5秒过后。第二线程与主线程并发运行
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		/**
		 * 主线程：循环输出一句话
		 */
		for (int i = 0; i < 10; i++) {

			System.out.println("I am Main Thread");
		}
	}
}

　　执行结果：

　　4.3  yield方法

　　Thread类的静态方法。

暂停当前正在运行的线程对象，并运行其它线程。也就是高风亮节。自己先暂停一下，让给别人先运行一下下。

　　演示样例代码

　　线程类：

/**
 * 定义线程类（继承Thread类）
 *
 * @author wangzhipeng
 *
 */
public class Mythread3 extends Thread {
	public Mythread3(String s) {
		super(s);
	}

	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(getName() + ":  " + i);
			// 假设i能被10整除。则让出cpu运行主线程，也就是说输出结果的子线程i为0、5、10、15等时，下一个输出必然为主线程的输出（仅仅要主线程没有运行完成）
			if (i % 5 == 0) {
				yield();
			}
		}
	}
}

　　yield方法測试类：

/**
 * yield方法測试类
 *
 * @author wangzhipeng
 *
 */
public class TestYield {
	public static void main(String[] argStrings) {
		Mythread3 mythread3 = new Mythread3("------zhipeng");
		mythread3.start();
		// 主线程
		for (int i = 0; i < 100; i++) {
			System.out.println("-----MainThread " + i);
		}
	}
}

　　输出结果：

　　4.4  线程的优先级Priority

　　每个Java线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。Java优先级在MIN_PRIORITY（1）和MAX_PRIORITY（10）之间的范围内。默认情况下。每个线程都会分配一个优先级NORM_PRIORITY（5）。

　　具有较高优先级的线程对程序更重要。并且应该在低优先级的线程之前分配处理器时间。

然而，线程优先级不能保证线程运行的顺序，并且很依赖于平台。

　　演示样例程序

　　定义两个线程类：

public class T1 implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("----------T1");
		}
	}

}

public class T2 implements Runnable {

	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			System.out.println("T2");
		}
	}

}

　　測试类：

public class TestPriority {

	public static void main(String[] args) {
		Thread thread1 = new Thread(new T1());
		Thread thread2 = new Thread(new T2());
		thread1.setPriority(Thread.NORM_PRIORITY + 5);// 给thread1线程的优先级加5。这样它被调度的机会就会比thread2大非常多
		thread1.start();
		thread2.start();
	}

}

　　执行结果：

五、    总结

进程是系统资源分配的基本单元，它是程序的执行演示样例，能够独立存在。线程是cpu调度的基本单元，是一个程序内部的控制流程，不能独立存在。必须依附于进程。一个进程包括多个线程，进程是为了得到系统资源，但实际上运作这些系统资源的都是线程。

通过对多线程的使用，能够编写出非常高效的程序。只是请注意，假设你创建太多的线程，程序运行的效率实际上是减少了。而不是提升了。由于，上下文的切换开销也非常重要。假设你创建了太多的线程，CPU花费在上下文的切换的时间将多于运行程序的时间！