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 {@Overridepublic 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 {@Overridepublic 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方法

　　很简单很常用，是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()两种方式都是比较粗暴的方式，即强行终止，一般不采用。而是在线程类中定义一个信号量，然后客户端通过给该信号量赋值来“温和”地控制线程的终止。例如给下面的线程类中的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 {@Overridepublic void run() {for (int i = 0; i < 1000; i++) {System.out.println("----------T1");}}}

public class T2 implements Runnable {@Overridepublic 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花费在上下文的切换的时间将多于执行程序的时间！