操作系统进程和线程概念

　　进程与线程

　　先阐述一下进程和线程的概念和区别，这是一个许多大学老师也讲不清楚的问题。

　　进程（Process）是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位。程序只是一组指令的有序集合，它本身没有任何运行的含义，只是一个静态实体。而进程则不同，它是程序在某个数据集上的执行，是一个动态实体。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消，反映了一个程序在一定的数据集上运行的全部动态过程。

　　线程（Thread）是进程的一个实体，是CPU调度和分派的基本单位。线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

　　线程和进程的关系是：线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与属于同一进程的其它线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。

 

进程是程序运行的最小单位。

线程是CPU调度的最小单位。

以下对线程的使用方法进行测试：

view plaincopy to clipboardprint?
package com.thread;  
/** 
 * java线程测试类 
 * @author 陈新杰 
 * 
 */ 
public class TestThread {  
    /** 
     * @param args 
     */ 
    public static void main(String[] args)  
    {  
        // TODO Auto-generated method stub  
        testInnerRunnableThread();  
        testInnerThread();  
        new Thread(new MyRunable()).start();  
        new Thread(new MyRunable()).start(); //不同对象可以调用各自的start（）方法  
          
        MyThread myThread = new MyThread();  
        myThread.start();  
        //myThread.start();  同一不可以调用多个start（）方法  
          
        //testThreadStop();  
        testThreadStopWithinterrupt();  
          
          
    }  
    /** 
     * 测试线程的关闭 
     */ 
    private static void testThreadStop()  
    {  
        System.out.println("开始！");  
        Thread thread = new Thread() {  
            public void run()  
            {  
                while (true) {  
                    try {  
                        Thread.sleep(1000);  
                    } catch (InterruptedException e) {  
                        // TODO Auto-generated catch block  
                        e.printStackTrace();  
                        System.out.println("");  
                        System.out.println("中断退出！");  
                        break;  
                    }  
                    System.out.println("子线程执行ing！");  
                }  
            }  
        };  
        thread.start();  
        try {  
            Thread.sleep(5000);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
             
        }  
          
        System.out.println("停止子线程！");  
        // 主线程等待5秒，终止子线程！退出！  
        // thread.stop();  
        thread.interrupt();  
        System.out.println("主线程结束！");  
    }  
      
    /** 
     * 测试线程的关闭,通过中断标志isInterrupted停止线程执行 
     */ 
    private static void testThreadStopWithinterrupt()  
    {  
        System.out.println("开始！");  
        Thread thread = new Thread() {  
            public void run()  
            {  
                while (true&&!Thread.currentThread().isInterrupted()) {  
                    System.out.println("子线程执行ing！");  
                }  
            }  
        };  
        thread.start();  
        try {  
            Thread.sleep(5000);  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
             
        }  
          
        System.out.println("停止子线程！");  
        // 主线程等待5秒，终止子线程！退出！  
        // thread.stop();  
        thread.interrupt();  
        System.out.println("主线程结束！");  
    }  
    /** 
     * 测试匿名线程类 
     */ 
    private static void testInnerRunnableThread()  
    {  
        new Thread(new Runnable() {  
            @Override 
            public void run()  
            {  
                // TODO Auto-generated method stub  
                System.out.println("InnerRunnableThread 正在运行！");  
            }  
        }).start();  
    }  
    /** 
     * 测试匿名线程类 
     */ 
    private static void testInnerThread()  
    {  
        new Thread() {  
            public void run()  
            {  
                System.out.println("InnerThread 正在运行！");  
            }  
        }.start();  
    }  
}  
/** 
 * 测试继承自Thread的线程类 
 * @author 陈新杰 
 * 
 */ 
class MyThread extends Thread {  
    @Override 
    public void run()  
    {  
        // TODO Auto-generated method stub  
        System.out.println("MyThread 正在运行！");  
    }  
}  
/** 
 * 测试实现Runnable接口的线程类 
 * @author 陈新杰 
 * 
 */ 
class MyRunable implements Runnable {  
    @Override 
    public void run()  
    {  
        // TODO Auto-generated method stub  
        System.out.println("MyRunable 正在运行！");  
    }  
} 
package com.thread;
/**
 * java线程测试类
 * @author 陈新杰
 *
 */
public class TestThread {
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        testInnerRunnableThread();
        testInnerThread();
        new Thread(new MyRunable()).start();
        new Thread(new MyRunable()).start(); //不同对象可以调用各自的start（）方法
       
        MyThread myThread = new MyThread();
        myThread.start();
        //myThread.start();  同一不可以调用多个start（）方法
       
        //testThreadStop();
        testThreadStopWithinterrupt();
       
       
    }
    /**
     * 测试线程的关闭
     */
    private static void testThreadStop()
    {
        System.out.println("开始！");
        Thread thread = new Thread() {
            public void run()
            {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                        System.out.println("");
                        System.out.println("中断退出！");
                        break;
                    }
                    System.out.println("子线程执行ing！");
                }
            }
        };
        thread.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          
        }
       
        System.out.println("停止子线程！");
        // 主线程等待5秒，终止子线程！退出！
        // thread.stop();
        thread.interrupt();
        System.out.println("主线程结束！");
    }
   
    /**
     * 测试线程的关闭,通过中断标志isInterrupted停止线程执行
     */
    private static void testThreadStopWithinterrupt()
    {
        System.out.println("开始！");
        Thread thread = new Thread() {
            public void run()
            {
                while (true&&!Thread.currentThread().isInterrupted()) {
                    System.out.println("子线程执行ing！");
                }
            }
        };
        thread.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
          
        }
       
        System.out.println("停止子线程！");
        // 主线程等待5秒，终止子线程！退出！
        // thread.stop();
        thread.interrupt();
        System.out.println("主线程结束！");
    }
    /**
     * 测试匿名线程类
     */
    private static void testInnerRunnableThread()
    {
        new Thread(new Runnable() {
            @Override
            public void run()
            {
                // TODO Auto-generated method stub
                System.out.println("InnerRunnableThread 正在运行！");
            }
        }).start();
    }
    /**
     * 测试匿名线程类
     */
    private static void testInnerThread()
    {
        new Thread() {
            public void run()
            {
                System.out.println("InnerThread 正在运行！");
            }
        }.start();
    }
}
/**
 * 测试继承自Thread的线程类
 * @author 陈新杰
 *
 */
class MyThread extends Thread {
    @Override
    public void run()
    {
        // TODO Auto-generated method stub
        System.out.println("MyThread 正在运行！");
    }
}
/**
 * 测试实现Runnable接口的线程类
 * @author 陈新杰
 *
 */
class MyRunable implements Runnable {
    @Override
    public void run()
    {
        // TODO Auto-generated method stub
        System.out.println("MyRunable 正在运行！");
    }
}
 

实现多线程程序的两种方式：
从Thread类继承；
实现Runnable接口。唯一的一个要实现的方法是void run()。通过完成Runnable接口，实现一个线程类。

同一个线程对象的start（）方法不能多次调用。但润run（）可以，通过start（）方法将线程交给CPU处理。

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/shui1/archive/2010/11/15/6009307.aspx