并发与多线程（一）

（一）多线程
多个线程共享单个CPU，线程之间竞争CPU资源。
（二）多线程的优势
如果采用单线程：当一个线程在等待用户输入数据时（即当前线程并没有使用CPU），其他线程也无法取得CPU资源，导致CPU大部分时间都是空闲的，CPU的利用率很低。

多线程则大大提高了CPU的利用率。多线程允许在输入文字的同时，打印或者保存文件。多线程可以使程序反应更快，交互性更强，执行效率更高。
（三）创建任务与创建线程
1）任务就是对象。为了创建任务，首先要定义一个任务类，实现了Runnable接口的类就是任务类。Runnable接口十分简单，只定义了一个run()方法。定义了一个任务类，就可以通过它的构造方法创建一个任务。代码示例：

//定义了一个任务类MyRunnerable
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        //Runnable接口很简单，只定义了一个run()方法
        //必须要实现Runnable接口的run()方法
    }
}

public static void main(String[] args) {
    //创建了一个任务
    Runnable runnable1=new MyRunnable();
}

2）任务必须在线程中运行。Thread类中包括创建线程的构造方法、启动线程的方法、控制线程的方法。下面来看一下如何创建线程吧。

    public static void main(String[] args) {
        //创建一个空的线程
        Thread thread1=new Thread();

        //创建了一个任务
        Runnable runnable1=new MyRunnable();
        //为一个任务创建一个线程
        Thread thread2=new Thread(runnable1);

    }

（四）实现多线程的2种方式
方式一：实现Runnable接口的方式
①定义任务类，实现Runnable接口，创建任务，为任务创建线程。该种方式就是上面采用的方式。
②把任务作为构造参数传给Thread。当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

    public void run() {
        if (target != null) {
            target.run();
        }
    }

③代码示例：

//定义了一个任务类MyRunnerable
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=1;i<=1000;i++){
            System.out.println(i);
        }
    }
}

    public static void main(String[] args) {
        Runnable runnable=new MyRunnable();
        Thread thread=new Thread(runnable);
        thread.start();
    }

方式二：继承Thread类
①因为Thread类实现了Runnable接口，所以，可以定义一个Thread类的继承类，并且重写run方法。然后在客户端程序中创建这个类的一个对象，并且调用它的start方法启动线程。
②代码示例

//继承Thread类，重写run()方法
public class MyThread extends Thread {
    @Override
    public void run() {
        //
    }
}

    public static void main(String[] args) {
        MyThread thread=new MyThread();
        thread.start();
    }

③但是这种方式不推荐使用，因为它将任务和运行任务的机制混在了一起，任务就在线程之中。将任务从线程中分离出来是比较好的设计。推荐使用方式一。
（五）线程的状态及状态转变
1）线程有5种状态：新（初始）状态，就绪（可运行）状态，运行状态，阻塞状态，死亡状态。
2）状态转变图

3）说明
①新状态（初始状态）：线程对象已经创建，还没有调用它的start()方法
②只有处于就绪状态的线程，才有机会获取CPU，从而进入到运行状态
③处于阻塞状态的线程，没办法获取CPU，必须进入到就绪状态才能竞争CPU
④Thread.sleep(long millis)能让当前正在运行的线程变成阻塞状态；Thread.yield()能让当前正在运行的线程变成就绪状态；join()能让当前线程进入到阻塞状态，直到该线程所加入的线程完成为止
（六）认识Thread类
1）常用的构造方法
①Thread():创建一个空的Thread对象
②Thread(Runnable target):为一个任务创建一个Thread对象
③Thread(String name):创建任务时指定线程名，如果没有指定，则会自动为它生成线程名。每个线程都有线程名，线程名可以相同。
④Thread(Runnable target, String name):指定线程名，指定任务
2）一些简单方法（获取线程的相关信息）
①public final String getName();//返回该线程的名称
②public final void setName(String name);//修改线程名
③public final int getPriority();//返回线程的优先级
④public final void setPriority(int newPriority);//更改线程的优先级

    Thread.MAX_PRIORITY等于10
    Thread.MIN_PRIORITY等于1
    Thread.NORM_PRIORITY等于5
    线程的默认优先级是5；修改线程的优先级时，必须保证优先级在1-10之间，否则会抛出IllegalArgumentException异常；数字越大，优先级越大。

⑤public String toString();//返回该线程的字符串表示形式，包括线程名称、优先级和线程组。

    public String toString() {
        ThreadGroup group = getThreadGroup();
        if (group != null) {
            return "Thread[" + getName() + "," + getPriority() + "," +
                           group.getName() + "]";
        } else {
            return "Thread[" + getName() + "," + getPriority() + "," +
                            "" + "]";
        }
    }

3）控制线程的方法
①public void start();//使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
注意，1个线程只能启动1次。当一个线程已经启动了，不能再次启动。特别是当线程已经执行结束了，不得重新启动。
②public final boolean isAlive();//判断线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态，返回true
③public final void join();//让当前线程等待该线程终止

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable1=new MyRunnable();
        Thread thread2=new Thread(runnable1);
        thread2.start();//启动线程

        for(int i=1;i<=100;i++){
            System.out.println(i);
            if(i==50){
                //当i==50时，让主线程main等待thread2终止
                //主线程要等thread2执行完成后，再去执行
                thread2.join();
            }
        }
    }

④public final void join(long millis);//等待该线程终止的时间最长为 millis 毫秒
⑤public static void sleep(long millis);//让当前正在执行的线程休眠millis毫秒
让当前线程休眠（当前线程进入到阻塞状态），让出CPU，那么其他线程就可以获得CPU。

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable1=new MyRunnable();
        Thread thread2=new Thread(runnable1);
        thread2.start();//启动线程

        for(int i=1;i<=100;i++){
            System.out.println(i);
            if(i==10){
                //当i等于10，让当前线程休眠5s。那么thread2将会获得CPU
                Thread.sleep(5000);
            }
        }
    }

当前线程执行了sleep(long millis)方法后，将转到阻塞状态。等待millis毫秒后，睡眠结束，会进入到就绪状态。
⑥public static Thread currentThread();//返回对当前正在执行的线程对象的引用，获取当前线程
⑦public static void yield();//暂停当前正在执行的线程对象
让当前正在执行的线程放弃CPU，转为就绪状态。相同优先级或者更高优先级的线程将有机会获得CPU。
yield()方法只会给相同优先级或者更高优先级的线程一个运行的机会。
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行，所以不一定能观察到效果。
⑧public static boolean interrupted();//判断当前线程是否已经中断
⑨public void interrupt();//中断线程
⑩public boolean isInterrupted();//判断线程是否已经中断