重学多线程（一）—— 线程简介

线程的定义

• 线程有时候又被称为轻量级进程，是程序执行的最小单元。一个进程可对应多个线程，而一个线程只属于一个进程。

多线程的好处

• 资源利用率更好
  一个单线程程序在运行时只能使用一个处理器核心，那么再多的处理器核心加入也无法显著提升该程序的执行效率。相反，如果该程序使用多线程技术，将计算逻辑分配到多个处理器核心上，就会显著减少程序的处理时间，并且随着更多处理器核心的加入而变得更有效率。

• 程序设计在某些情况下更简单
  Java为多线程编程提供了良好、考究并且一致的编程模型，使得开发人员能够更加专注于问题的解决，即为所遇到的问题建立合适的模型，而不是绞尽脑汁地考虑如何将其多线程化。

• 程序响应更快
  使用多线程技术，可以将数据一致性不强的操作派发给其他线程处理。这样做的好处是响应用户请求的线程能够尽可能快地处理完成，缩短响应时间，提升用户体验。

线程的状态

线程状态枚举

public enum State {

        //初始状态，线程被构建，但是还没有调用start（）方法
        NEW,

        //运行状态，Java线程将操作系统中的就绪和运行两种状态笼统地称作“运行中”
        RUNNABLE,

        //阻塞状态，表示线程被锁阻塞
        BLOCKED,

        //等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程的做出一些特定动作，例如通知或者中断
        WAITING,

        //超时等待状态，该状态不同于WAITING，它是可以在指定的时间自行返回的
        TIMED_WAITING,

        //终止状态，表示当前线程已经执行完毕
        TERMINATED;
    }

线程状态流转

线程的优先级

线程分配到的时间片多少也就决定了线程使用处理器资源的多少，而线程的优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。
在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程创建的时候可以通过setPriority(int)方法来修改优先级，默认优先级为5。

    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

线程的创建

继承java.lang.Thread类

public class ThreadTest extends Thread{
    int i = 0;
    //重写run方法，run方法的方法体就是现场执行体
    public void run()
    {
        for(;i<10;i++){
            System.out.println(getName()+"  "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args)
    {
        new ThreadTest().start();
        new ThreadTest().start();
    }
}

实现java.lang.Runnable接口

public class RunnableTest implements Runnable {
    private int i;
    public void run()
    {
        for(;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"  "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args)
    {
        Runnable r = new RunnableTest();
        new Thread(r).start();
        new Thread(r).start();
    }
}

实现java.util.concurrent.Callable接口;

public class CallableTest implements Callable<Integer> {
    public static void main(String[] args)
    {
        CallableTest ctt = new CallableTest();
        FutureTask<Integer> ft = new FutureTask<Integer>(ctt);

        new Thread(ft,"有返回值的线程").start();
        try
        {
            System.out.println("子线程的返回值："+ft.get());
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        } catch (ExecutionException e)
        {
            e.printStackTrace();
        }

    }

    public Integer call() throws Exception
    {
        int i = 0;
        for(;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+" "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return i;
    }
}

启动和暂停线程

启动线程

Thread.start()方法；

暂停线程

• 过期的suspend()、resume()和stop()方法；

• interrupted()、isInterrupted()方法
  this.interrupted():测试当前线程是否已中断，线程的中断状态由该方法清除，也就是如果连续两次调用该方法，则第二次调用将返回false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

  this.isInterrupted():测试线程Thread对下岗是否已是中断状态，不清除状态标志。