黑马程序员-----java线程学习与总结

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1、线程的概念
Thread，是一个进程更加微观的一个对象。进程是OS任务调度的最基本单位。
独立性：线程不能独立存在，线程依赖于进程存在。
存储区域：进程中的数据存在堆栈中，线程的数据存在于寄存器中。
粒度：线程小，进程大。

2、Java中关于线程的API
线程的API包括一个java.lang.Thread类和一个接口java.lang.Runnable接口。

Runnable接口只有一个抽象run()方法。而Thread类实际上是对Runnable接口的实现。

Thread的方法大概分为3类：
获取线程信息方法：getName()/getPriority()
设置线程信息方法：
setName()/setPriority()
有关线程生命周期的方法
Sleep()/join()/interrupt()/interrupted()/isAlive()/run()/resume()/suspend()/start()

 

3、实现线程的方式
Thread():构造一个缺省线程类
Thread(String name)：构造一个名称为name的线程类
Thread(Runnable r)：构造由R实现的线程类
Thread(Runnable r,String name)：构造由R实现，名称为name的线程。

我们定义线程类，核心机制重写run()方法，在run()方法中写线程的功能代码。

（1）自定义的类继承Thread类实现
第一步：定义run()方法

第二步：创建线程对象并启动线程，通过start()方法来间接调用run()方法，不能直接调用run()方法。

（2）自定义的类实现Runnable接口实现
第一步：定义run()方法
第二步：创建线程对象并启动线程。

如下：

package com.tai.GX;

public class ThreadText
{
    public static void main(String[] args)
    {
        //第一种实现方式  创建匿名Thread的子类，复写Thread的run方法 运行的时候就会自动调用run方法
        new Thread(){
            public void run() {
                while (true)
                {
                    try
                    {
                        Thread.sleep(1500);
                        System.out.println(this.getName());//这里的this 就是当前正在运行的线程  相当于 Thread.currentThread
                        system.out.println("this Thread can do something footloose!");
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }                    
                }
            };
        }.start();
        //第二种实现方式 创建Thread是传入一个Runnable接口的子类并复写其Run方法
        new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                while (true)
                {
                    try
                    {
                        Thread.sleep(1500);
                        System.out.println(Thread.currentThread().getName());
                        system.out.println("this Thread can do something footloose!");
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }    
                }
            }
        }).start();
        
        //因为Thread也实现了Runnable接口这里也可以这样用，我就是试试  其实不合理的
        new Thread(new Thread(){
            @Override
            public void run()
            {
                while (true)
                {
                    try
                    {
                        Thread.sleep(1500);
                        System.out.println(this.getName());
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
        
        //这里的既复写Thread的run方法 又传入了Runnable子类 这时候会发生什么情况呢 ？
        
        //这时候就需要看源码了：Thread类中有个Runnable对象，也就是构造方法传入的对象   Thread类的run方法会先判断时候有传入Runnable对象
        //有的话就执行Runnable类的run方法  但是，这里复写了Thread的run方法，所以执行的时候就会执行子类复写过的run方法,所以这里就打印出
        //From Runnable subClass!
        //From this thread!
        
        //super.run就是先调用负类的方法  如果去掉就不会打印出Runnable子类方法中的输出语句
        new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                System.out.println("From Runnable subClass!");
            }
        }){
            public void run() {
                super.run();
                System.out.println("From this thread!");
            };
        }.start();
        
    }
}

4、线程的生命周期
创建：使用new运算符实例化一个线程对象，那么该线程对象就创建了。通过调用start()方法，可以启动该线程并且进入了就绪阶段。
就绪：就绪阶段可以分为两种情况：可运行状态（Runnable），正在运行状态（Running）。在任意一个时间片，只能有一个线程控制CPU。控制CPU的线程称为正在运行的线程，其他的线程称为可运行状态。
阻塞：处于阻塞状态的线程就失去了争抢CPU控制权的资格。阻塞状态又分为4种情况：休眠、等待、中断、挂起。
就绪休眠：sleep(n),经过n ms后该线程自动返回到就绪状态。
就绪挂起：suspend()，反过来使用resume()恢复该线程到就绪状态。这两对方法不推荐使用。
就绪中断：interrupt()方法，反过来，使用interrupted()方法。
就绪等待:wait()方法，反过来，使用notify()/notifyAll().
死亡：一个线程一旦运行完毕，即进行死亡状态，释放自身占用的资源。从死亡状态无法再返回到其他状态。

public class SuspendThread extends Thread {
    //定义构造方法
    public SuspendThread(String name)
    {
        super(name);
    }
    //线程 体
    public void run()
    {
        System.out.println("线程体开始执行");
        for(int i=0;i<1000000;i++)
        {
            double d = 10;
            d = Double.MAX_VALUE/i+1;
        }
        for(int j=1;j<11;j++)
        {
            System.out.println(Thread.currentThread().getName() + "循环了" + j +"次");
            if(j==5)
            {
                sleepThread(Thread.currentThread(),5000);
            }
        }
        System.out.println("线程体执行完毕"); //死亡状态
    }
    public static void sleepThread(Thread t,long time)
    {
        if(t.isAlive())
            try {
                System.out.println("线程开始休眠");
                t.sleep(time);
                System.out.println("线程已醒，返回到就绪状态");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }
    
    /**
     * 挂起一个线程t
     * @param t
     */
    @SuppressWarnings("deprecation")
    public static  void suspendThread(Thread t)
    {
        //判断线程是否处于活动状态 ，指的就是就绪状态
        if(t.isAlive())
        {
            t.suspend();
            
            System.out.println("线程已挂起");
        }
    }
    /**
     * 恢复被挂起的线程
     * @param t
     */
    public static void resumeThread(Thread t)
    {
        if(!t.isInterrupted())
        {
            t.resume();
            System.out.println("线程已恢复！");
        }
    }
    
    public static void main(String args[])
    {
        SuspendThread st = new SuspendThread("A#");//创建状态
        st.start();//就绪状态
        
        //suspendThread(st);//阻塞状态 --挂起
        //resumeThread(st);//将挂起的线程恢复，线程又重新进入了就绪状态
    }
}

几个复杂的方法：
isAlive()：是否处于活动状态，活动状态指的是从启动到死亡之间的时刻。
yield()：一个正在运行的线程调用该方法后，失去CPU的控制权，重新和其他处于就绪状态的线程争抢CPU的控制权。

public class YieldThread extends Thread{
    public YieldThread(String name)
    {
        super(name);
    }
    public void run()
    {
    
        for(int j=1;j<11;j++)
        {
            System.out.println(Thread.currentThread().getName() + "循环了" + j +"次");    
            if(j==3)
            {
                //让当前正在运行的线程放弃CPU的控制权
                Thread.currentThread().yield();
            }
        }
    }

    public static void main(String[] args) {
        for(int i=1;i<6;i++)
        {
            new YieldThread(i+"#").start();
        }

    }
}

join():让其他处于就绪状态的线程等待当前正在执行的线程。A正在执行B.join(long t)方法，B线程加入，其他线程待B执行完毕或者执行t毫秒后再执行。

public class JoinTest extends Thread{

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        JoinTest t1 = new JoinTest("T1");
        JoinTest t3 = new JoinTest("T3");
        JoinTest t2 = new JoinTest("T2");
        t3.start();
        t1.start();
        t2.start();
        try {
            t2.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }

    public JoinTest(String name)
    {
        super(name);
    }

    public void run()
    {
        System.out.println(this.getName() + "线程开始执行，当前时间：" + System.currentTimeMillis());
        for(int i=1;i<6;i++)
        {        
            System.out.println(this.getName() + "循环体循环了" + i + "次");
        }
        System.out.println(this.getName() + "线程执行结束，当前时间：" + System.currentTimeMillis());        
    }
}

interrupt()：中断一个线程。无论线程处于中断状态与否，isAlive()方法总是返回true.
interrupted():判断线程是否处于中断状态，如是中断状态返回true，并且将终止中断状态，返回到就绪状态。

isInterrupted():判断线程是否处于中断状态，如是中断状态返回true，否则false。并且当前线程的中断状态不会被清除。

public class SuspendThread extends Thread {
    //定义构造方法
    public SuspendThread(String name)
    {
        super(name);
    }
    //线程 体
    public void run()
    {
        System.out.println("线程体开始执行");
        for(int i=0;i<1000000;i++)
        {
            double d = 10;
            d = Double.MAX_VALUE/i+1;
        }
        for(int j=1;j<11;j++)
        {
            System.out.println(Thread.currentThread().getName() + "循环了" + j +"次");
            if(j==5)
            {
                //sleepThread(Thread.currentThread(),5000);
            }
        }
        System.out.println("线程体执行完毕"); //死亡状态
    }
    public static void sleepThread(Thread t,long time)
    {
        if(t.isAlive())
            try {
                System.out.println("线程开始休眠");
                t.sleep(time);
                System.out.println("线程已醒，返回到就绪状态");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    }
    
    /**
     * 挂起一个线程t
     * @param t
     * @throws InterruptedException 
     */
    @SuppressWarnings("deprecation")
    public static void suspendThread(Thread t) 
    {
        
        //判断线程是否处于活动状态 ，指的就是创建状态到死亡之间时段
        if(t.isAlive())
        {
            t.interrupt();
            System.out.println("是否处于活动状态？" + t.isAlive());
            System.out.println("线程已挂起");
        }
    }
    /**
     * 恢复被挂起的线程
     * @param t
     */
    public static void resumeThread(Thread t)
    {
        if(t.isInterrupted()) //true
        {
            t.interrupted(); //清除中断
            
            System.out.println("线程已恢复！");
        }
    }
    
    public static void main(String args[])
    {
        SuspendThread st = new SuspendThread("A#");//创建状态
        st.start();//就绪状态
        
        suspendThread(st);//阻塞状态 --挂起
        resumeThread(st);//将挂起的线程恢复，线程又重新进入了就绪状态
    
    }
}

5、线程的优先级
线程的优先级分为10个等级：1-10，1最低，10最高。Java的Thread类同时提供了3个常量表示优先级：MIN_PRIORITY (1), NORM_PRIORITY(5),MAX_PRIORITY(10)，推荐为线程设置优先级时使用常量不要用数字。
线程的默认优先级是5