java基础学习总结-----线程(一)

转：基础学习总结----线程(一)http://www.cnblogs.com/xdp-gacl/p/3633936.htmljava

一、线程的概念

线程：线程是一个程序里面不同的执行路径

进程：一个静态的概念，机器上的一个.class文件，机器上的一个.exe文件，这个叫做一个进程。

程序的执行过程：

1.首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始，进程已经产生，但还没有开始执行，这就是进程。其实是2.一进程的执行指的是进程里面主线程（也就是main()方法）开始执行了。

3.进程是一个静态的概念，在我们机器里面实际上运行的都是线程。

4.实际上在一个时间点上，CPU只有一个线程在运行，因为CPU运行的速度很快，因此我们看起来的感觉就像是多线程一样。

二、线程的创建和启动

1.在JAVA里面，JAVA的线程是通过java.lang.Thread类来实现的，每一个Thread对象代表一个新的线程。

2.你只要new一个Thread对象，一个新的线程也就出现了。

3.每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。

程序示例1：

public class TestThread1 {
    public static void main(String args[])
    {
        //new一个线程类对象r1,r1要调用run()方法才能启动
        Runner1 r1 = new Runner1();
        
        //要启动一个新的线程t就必须new一个Thread对象出来
        //这里使用的是Thread(Runnable target)构造方法
        Thread t = new Thread(r1);
        
        //启动线程t,t线程执行的是run()方法，它与主线程r1会一起并行执行    
        t.start();
        
        for(int i = 0; i < 10; i++)
        {
            System.out.println("maintheod:" + i);
        }
    }
}

//定义一个类用来实现Runnable接口，实现Runnable接口就表示这个类是一个线程类
class Runner1 implements Runnable
{
    public void run()
    {
        for(int i = 0; i <10; i++)
        {
            System.out.println("Runner1:" + i);
        }
    }
}

程序精华解析：

 

程序运行结果：

不开辟新线程直接调用run方法

结果：

 

程序示例2：

继承Thread类，并重写它的run（）方法创建和启动新的线程

例子

public class TestThread2 {
    public static void main(String args[])
    {
        Runner2 r2 = new Runner2();
        r2.start();
        for(int i = 0; i<=10; i++ )
        {
            System.out.println("mainMethod:" + i);
        }
    }
}
//Runner2类从Thread类继承
//通过实例化Runner2类的一个对象可以开辟一个新的线程
//调用从Thread类继承来的start()方法可以启动新开辟的线程
class Runner2 extends Thread
{
    public void run()
    {//重写run()方法的实现
        for(int i=0;i<=10;i++)
        {
            System.out.println("Runner2："+i);
        }
    }
}

使用实现Runnable接口和继承Thread类这两种开辟新线程的方法的选择应该优先选择实现Runnable接口这种方式去开辟一个新的线程。因为接口的实现可以实现多个，而类的继承只能是单继承。因此在开辟新线程时能够使用Runnable接口就尽量不要使用从Thread类继承的方式来开辟新的线程。

三、线程状态转换

import java.util.Date;

public class sleep 
{
    public static void main(String args[])
    {
        MyThread thread = new MyThread();
        //调用start方法启动新开辟的进程
        thread.start();
        try
        {
            MyThread.sleep(10000);
            //在哪个线程里面调用sleep()方法就让哪个线程睡眠，现在是主线程睡眠
            System.out.println("主线程睡眠了10秒后再次启动了");
        }catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        //thread.interrupt();//使用interrupt()方法结束一个线程不是一个很好的做法
        thread.flag = false;//改变循环条件，结束死循环
         /**
         * 当发生InterruptedException时，直接把循环的条件设置为false即可退出死循环，
         * 继而结束掉子线程的执行，这是一种比较好的结束子线程的做法
         */
        /**
         * 调用interrupt()方法把正在运行的线程打断
            相当于是主线程一盆凉水泼上去把正在执行分线程打断了
            分线程被打断之后就会抛InterruptedException异常，这样就会执行return语句返回，结束掉线程的执行
            所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
         */
    }    
}

class MyThread extends Thread
{
    //定义一个标志用来控制循环的条件
    boolean flag = true; 
    
    public void run()
    {
        /*
         * 注意：这里不能在run()方法的后面直接写throw Exception来抛异常， 
         * 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。
         *  所以这里只能写try……catch()来捕获异常
         */
        while(flag)
        {
            //toLocaleString返回一个表示该Date对象的"本地化"字符串，
            System.out.println("============" + new Date().toLocaleString()+ "========");
            try
            {
                sleep(1000);//睡眠的时如果被打断就会抛出InterruptedException异常
                // 这里是让这个新开辟的线程每隔一秒睡眠一次，然后睡眠一秒钟后再次启动该线程
                // 这里在一个死循环里面每隔一秒启动一次线程，每个一秒打印出当前的系统时间
            }catch(InterruptedException e)
            {
                 /*
                 * 睡眠的时一盘冷水泼过来就有可能会打断睡眠 
                 * 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
                 */
                return;
                // 线程被中断后就返回，相当于是结束线程
            }
        }
    }
}

public class join {
    public static void main(String args[])
    {
        //在创建一个新的线程对象的同时给这个线程对象命名为mythread
        MyThread2 thread2 = new MyThread2("mythread");
        //启动线程
        thread2.start();
        try
        {
            //调用join()方法合并线程，将子程序mythread合并到主线程里面
            thread2.join();
            //合并线程后，程序的执行的过程相当于是方法的调用的执行过程
        }catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        for(int i = 0; i<= 5; i++)
        {
            System.out.println("I am main Thread");
        }        
    }
}

class MyThread2 extends Thread
{
    MyThread2(String s)
    {
        super(s);
         /*
         * 使用super关键字调用父类的构造方法 
         * 父类Thread的其中一个构造方法：“public Thread(String name)” 
         * 通过这样的构造方法可以给新开辟的线程命名，便于管理线程
         */
    }
    
    public void run()
    {
        for(int i = 1;i<=5;i++)
        {
            System.out.println("I am a	" + getName());
            // 使用父类Thread里面定义的
            //public final String getName()，Returns this thread's name.
            try
            {
                //线程每执行一次就睡眠1秒钟
                sleep(1000);
            }catch(InterruptedException e)
            {
                return;
            }
        }
    }
}