Java复习--线程基本概念

转自http://www.cnblogs.com/mengdd/archive/2013/02/16/2913628.html

线程概念

　　线程就是程序中单独顺序的流控制。

　　线程本身不能运行，它只能用于程序中。

　　说明：线程是程序内的顺序控制流，只能使用分配给程序的资源和环境。

 

进程

　　进程：执行中的程序。

　　程序是静态的概念，进程是动态的概念。

　　一个进程可以包含一个或多个线程。

　　一个进程至少要包含一个线程。

 

线程与进程的区别

　　多个进程的内部数据和状态都是完全独立的，而多线程是共享一块内存空间和一组系统资源，有可能互相影响。

　　线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换负担比进程切换的负担要小。

　　多线程程序比多进程程序需要更少的管理费用。

　　进程是重量级的任务，需要分配给它们独立的地址空间，进程间通信是昂贵和受限的，进程间的转换也是很需要花费的。

　　另一方面，线程是轻量级的选手，它们共享相同的地址空间并且共同分享同一个进程，线程间的通信是便宜的，线程间的转换也是低成本的。

Java中的多线程

　　同其他大多数编程语言不同，Java内置支持多线程编程(Multithreaded Programming)。

　　多线程程序包含两条或两条以上并发运行的部分，程序中每个这样的部分都叫做一个线程（Thread）。每个线程都有独立的执行路径，因此多线程是多任务处理的一种特殊形式。

　　多任务处理被所有的现代操作系统所支持。然而，多任务处理有两种截然不同的类型：基于进程的和基于线程的。

　　1.基于进程的多任务处理是更熟悉的形式。进程（process）本质上是一个执行的程序。因此基于进程的多任务处理的特点是允许你的计算机同时运行两个或更多的程序。

　　举例来说，基于进程的多任务处理使你在运用文本编辑器的时候可以同时运行Java编译器。

　　在基于进程的多任务处理中，程序是调度程序所分派的最小代码单位。

　　2.而在基于线程（thread-based）的多任务处理环境中，线程是最小的执行单位。

　　这意味着一个程序可以同时执行两个或者多个任务的功能。

　　例如，一个文本编辑器可以在打印的同时格式化文本。

Java线程模型

　　Java多线程的优点就在于取消了主循环/轮询机制。一个线程可以暂停而不影响程序的其他部分。

　　多线程允许活的循环在每一帧间隙中沉睡一秒而不暂停整个系统。

 

线程组

　　所有线程都隶属于一个线程组。那可以是一个默认线程组，也可以是一个创建线程时明确指定的组。

　　说明：

　　在创建之初，线程被限制到一个组里，而且不能改变到一个不同的组。

　　若创建多个线程而不指定一个组，它们就会与创建它的线程属于同一个组。

线程的实现

　　在Java中通过run方法为线程指明要完成的任务，有两种技术来为线程提供run方法：

　　1.继承Thread类并重写它的run方法。之后创建这个子类的对象并调用start()方法。

　　2.通过定义实现Runnable接口的类进而实现run方法。这个类的对象在创建Thread的时候作为参数被传入，然后调用start()方法。

 

　　Thread类是专门用来创建线程和对线程进行操作的类。当某个类继承了Thread类之后，该类就叫做一个线程类。

　　两种方法均需执行线程的start()方法为线程分配必须的系统资源、调度线程运行并执行线程的run()方法。

　　start()方法是启动线程的唯一的方法。start()方法首先为线程的执行准备好系统资源，然后再去调用run()方法。一个线程只能启动一次，再次启动就不合法了。

　　run()方法中放入了线程的工作，即我们要这个线程去做的所有事情。缺省状况下run()方法什么也不做。

　　在具体应用中，采用哪种方法来构造线程要视情况而定。通常，当一个线程已经继承了另一个类时，就应该用第二种方法来构造，即实现Runnable接口。

　　下面给出两个例子来说明线程的两种实现方法，每个例子中都有两个线程：

public class ThreadTest1{    public static void main(String[] args)    {        Thread1 thread1 = new Thread1();        Thread2 thread2 = new Thread2();        thread1.start();        thread2.start();    }}class Thread1 extends Thread{    @Override    public void run()    {        for (int i = 0; i < 100; ++i)        {            System.out.println("Hello World: " + i);        }    }}class Thread2 extends Thread{    @Override    public void run()    {        for (int i = 0; i < 100; ++i)        {            System.out.println("Welcome: " + i);        }    }}

 

public class ThreadTest2{    public static void main(String[] args)    {        // 线程的另一种实现方法，也可以使用匿名的内部类        Thread thread1 = new Thread(new MyThread1());        thread1.start();        Thread thread2 = new Thread(new MyThread2());        thread2.start();    }}class MyThread1 implements Runnable{    @Override    public void run()    {        for (int i = 0; i < 100; ++i)        {            System.out.println("Hello: " + i);        }    }}class MyThread2 implements Runnable{    @Override    public void run()    {        for (int i = 0; i < 100; ++i)        {            System.out.println("Welcome: " + i);        }    }}

 

Thread类剖析

　　Thread类也实现了Runnable接口，因此实现了接口中的run()方法。

　　当生成一个线程对象时，如果没有为其指定名字，那么线程对象的名字将使用如下形式：Thread-number，该number是自动增加的数字，并被所有的Thread对象所共享，因为它是一个static的成员变量。

　　当使用第一种方式（继承Thread的方式）来生成线程对象时，我们需要重写run()方法，因为Thread类的run()方法此时什么事情也不做。

　　当使用第二种方式（实现Runnable接口的方式）来生成线程对象时，我们需要实现Runnable接口的run()方法，然后使用new Thread(new MyRunnableClass())来生成线程对象（MyRunnableClass已经实现了Runnable接口），这时的线程对象的run()方法会调用MyRunnableClass的run()方法。

 

停止线程

　　线程的消亡不能通过调用stop()命令，而是让run()方法自然结束。stop()方法是不安全的，已经废弃。

　　停止线程推荐的方式：设定一个标志变量，在run()方法中是一个循环，由该标志变量控制循环是继续执行还是跳出；循环跳出，则线程结束。

　　如代码例子中所示：

public class ControlThreadTest{    MyThreadClass r = new MyThreadClass();    Thread t = new Thread(r);    public void startThread()    {        t.start();    }    public void stopThread()    {        r.stopRunning();    }}class MyThreadClass implements Runnable{    private boolean flag = true;    @Override    public void run()    {        while (flag)        {            System.out.println("Do something.");        }    }    public void stopRunning()    {        flag = false;    }}

 

线程的生命周期

　　线程的生命周期：一个线程从创建到消亡的过程。

　　如下图，表示线程生命周期中的各个状态：

　　

 

 

　　线程的生命周期可以分为四个状态：

1.创建状态：

　　当用new操作符创建一个新的线程对象时，该线程处于创建状态。

　　处于创建状态的线程只是一个空的线程对象，系统不为它分配资源。

　　

2.可运行状态：

　　执行线程的start()方法将为线程分配必须的系统资源，安排其运行，并调用线程体——run()方法，这样就使得该线程处于可运行状态（Runnable）。

　　这一状态并不是运行中状态（Running），因为线程也许实际上并未真正运行。

　　

3.不可运行状态：

　　当发生下列事件时，处于运行状态的线程会转入到不可运行状态：

　　调用了sleep()方法；

　　线程调用wait()方法等待特定条件的满足；

　　线程输入/输出阻塞。

　　返回可运行状态：

　　处于睡眠状态的线程在指定的时间过去后；

　　如果线程在等待某一条件，另一个对象必须通过notify()或notifyAll()方法通知等待线程条件的改变；

　　如果线程是因为输入输出阻塞，等待输入输出完成。

　　

4.消亡状态：

　　当线程的run()方法执行结束后，该线程自然消亡。

线程的优先级

　　1.线程的优先级及设置

　　线程的优先级是为了在多线程环境中便于系统对线程的调度，优先级高的线程将优先执行。

　　一个线程的优先级设置遵从以下原则：

　　线程创建时，子继承父的优先级。

　　线程创建后，可通过调用setPriority()方法改变优先级。

　　线程的优先级是1-10之间的正整数。

　　1- MIN_PRIORITY

　　10-MAX_PRIORITY

　　5-NORM_PRIORITY

　　如果什么都没有设置，默认值是5。

　　但是不能依靠线程的优先级来决定线程的执行顺序。

 

　　2.线程的调度策略

　　线程调度器选择优先级最高的线程运行。但是，如果发生以下情况，就会终止线程的运行：

　　线程体中调用了yield()方法，让出了对CPU的占用权。

　　线程体中调用了sleep()方法，使线程进入睡眠状态。

　　线程由于I/O操作而受阻塞。

　　另一个更高优先级的线程出现。

　　在支持时间片的系统中，该线程的时间片用完。

多线程访问成员变量与局部变量

　　先看一个程序例子：

　　

public class HelloThreadTest{    public static void main(String[] args)    {        HelloThread r = new HelloThread();        Thread t1 = new Thread(r);        Thread t2 = new Thread(r);        t1.start();        t2.start();    }}class HelloThread implements Runnable{    int i;    @Override    public void run()    {        while (true)        {            System.out.println("Hello number: " + i++);            try            {                Thread.sleep((long) Math.random() * 1000);            }            catch (InterruptedException e)            {                e.printStackTrace();            }            if (50 == i)            {                break;            }        }    }}

　　该例子中，HelloThread类实现了Runnable接口，其中run()方法的主要工作是输出"Hello number: "字符串加数字i，并且同时递增i，当i到达50时，退出循环。

　　main()方法中生成了一个HelloThread类的对象r，并且利用这个一个对象生成了两个线程。

　　程序的执行结果是：顺次打印了0到49的数字，共50个数字。

　　这是因为，i是成员变量，则HelloThread的对象r只包含这一个i，两个Thread对象因为由r构造，所以共享了同一个i。

　　当我们改变代码如下时（原先的成员变量i被注释掉，增加了方法中的局部变量i）：

public class HelloThreadTest{    public static void main(String[] args)    {        HelloThread r = new HelloThread();        Thread t1 = new Thread(r);        Thread t2 = new Thread(r);        t1.start();        t2.start();    }}class HelloThread implements Runnable{    // int i;    // 若i是成员变量，则HelloThread的对象r只包含这一个i，两个Thread对象因为由r构造，所以共享了同一个i    // 打印结果是0到49的数字    @Override    public void run()    {        int i = 0;        // 每一个线程都会拥有自己的一份局部变量的拷贝        // 线程之间互不影响        // 所以会打印100个数字，0到49每个数字都是两遍        while (true)        {            System.out.println("Hello number: " + i++);            try            {                Thread.sleep((long) Math.random() * 1000);            }            catch (InterruptedException e)            {                e.printStackTrace();            }            if (50 == i)            {                break;            }        }    }}

　　如注释中所述，由于局部变量对于每一个线程来说都有自己的拷贝，所以各个线程之间不再共享同一个变量，输出结果为100个数字，实际上是两组，每组都是0到49的50个数字，并且两组数字之间随意地穿插在一起。　

 

得到的结论如下：

　　如果一个变量是成员变量，那么多个线程对同一个对象的成员变量进行操作时，它们对该成员变量是彼此影响的，也就是说一个线程对成员变量的改变会影响到另一个线程。

　　如果一个变量是局部变量，那么每个线程都会有一个该局部变量的拷贝（即便是同一个对象中的方法的局部变量，也会对每一个线程有一个拷贝），一个线程对该局部变量的改变不会影响到其他线程。