多线程基础（一）

一、进程和线程的概念

• 进程：运行中的某个程序或者应用，至少包含一个线程
• 线程：进程中负责执行的一个或者多个执行单元，归属于进程，且多个线程共享进程的资源
• 并发机制：多个线程同时运行，CPU给每个线程分配时间片，获得时间的线程运行，其他线程等待，由于时间片很短，从宏观上看是线程都在运行，微观上看是线程走走停停

二、线程的创建

1、继承Thread类，重写run()

public class MyThread extends Thread{
    private String name;
    MyThread(String name){
        this.name=name;
    }
    
    @Override
    public void run(){
        System.out.println("name"+name+",此线程的id为"+Thread.currentThread().getId());
    }
    
    public static void main(String[] args) {
        System.out.println("当前主线程id为："+Thread.currentThread().getId());
        MyThread myThread1 = new MyThread("线程1");
        myThread1.start();
        MyThread myThread2 = new MyThread("线程2");
        myThread2.run();
        
    }
}

输出如下：

image.png

小结：

• start()和run()方法的不同。start是启动线程，交给CPU去获取时间片并调用run方法。而用run方法相当于交给主线程去执行run，并不会创建新的线程。
• 线程1是先创建的，但是输出结果在后，说明线程的创建并不会阻塞主线程的执行

2、实现Runnable接口

public class MyRunnable implements Runnable {
    private String name;
    MyRunnable(String name){
        this.name = name;
    }
    public void run() {
        System.out.println("启动"+name+"：id为"+Thread.currentThread().getId());
    }
    
    public static void main(String[] args) {
        MyRunnable my = new MyRunnable("runnable线程");
        Thread thread = new Thread(my);
        thread.start();
    }
}

3、最简洁的启动线程的方式

new Thread(new Runnable(){
  public void run(){
        xxxxxx
  }
};).start();

三、线程的状态

• 创建（new）状态: 准备好了一个多线程的对象
• 就绪（runnable）状态: 调用了start()方法, 等待CPU进行调度
• 运行（running）状态: 执行run()方法
• 阻塞（blocked）状态: 暂时停止执行, 可能将资源交给其它线程使用
• 终止（dead）状态: 线程销毁

image.png

1、当线程进入就绪状态后，要等CPU分配到时间片之后，线程便真正进入运行状态。
2、线程在运行状态过程中，可能有多个原因导致当前线程不继续运行下去，比如用户主动让线程睡眠（睡眠一定的时间之后再重新执行）、用户主动让线程等待，或者被同步块给阻塞，此时就对应着多个状态：time waiting（睡眠或等待一定的事件）、waiting（等待被唤醒）、blocked（阻塞）。
3、当由于突然中断或者子任务执行完毕，线程就会被消亡。

注:sleep和wait的区别:

• sleep是Thread类的方法,wait是Object类中定义的方法.
• Thread.sleep不会导致锁行为的改变, 如果当前线程是拥有锁的, 那么
  Thread.sleep不会让线程释放锁.
• Thread.sleep和Object.wait都会暂停当前的线程. OS会将执行时间分配给其它线程. 区别是, 调用wait后, 需要别的线程执行notify/notifyAll才能够重新获得CPU执行时间.

四、线程API

1、sleep():线程休眠，且不会释放锁。

public class MyThreadAPI{
    private int i = 0;
    private Object object = new Object();
    
    public static void main(String[] args) {
        MyThreadAPI api = new MyThreadAPI();
        MyThreadSleep thread1 = api.new MyThreadSleep() ;
        MyThreadSleep thread2 = api.new MyThreadSleep() ;
        thread1.start();
        thread2.start();
    }
    class MyThreadSleep extends Thread{
        public void run(){
            synchronized (object) {
                i++;
                System.out.println(Thread.currentThread().getName()+"睡眠前i："+i);
                System.out.println(Thread.currentThread().getName()+"进入睡眠");
                try {
                    Thread.currentThread().sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"睡眠结束");
                i++;
                System.out.println(Thread.currentThread().getName()+"睡眠后i："+i);
            }
        }
    }
}

输出结果：

image.png

2、yield(),让出当前时间片，与sleep不同的是不可选择时间

public class MyThreadYeild extends Thread {
    public void run(){
        long start = System.currentTimeMillis();
        int count = 0;
        for(int i = 1;i<50000000;i++){
            count++;
            Thread.yield();
        }
        System.out.println("当前count为："+count);
        long end = System.currentTimeMillis();
        System.out.println("耗时："+(end-start)+"毫秒");
    }
    public static void main(String[] args) {
        MyThreadYeild thread = new MyThreadYeild();
        thread.start();
    }
}

输出可发现：不写thread.yield()方法时，执行时间较短

线程的sleep()方法和yield()方法有什么区别？
① sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会；
② 线程执行sleep()方法后转入阻塞（blocked）状态，而执行yield()方法后转入就绪（ready）状态；
③ sleep()方法声明抛出InterruptedException，而yield()方法没有声明任何异常；
④ sleep()方法比yield()方法（跟操作系统CPU调度相关）具有更好的可移植性。

3、join()方法

主线程创建并启动了线程，如果子线程中要进行大量耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。

public class MyThread4 extends Thread {
    public MyThread4(String name){
        super(name);
    }
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(getName() + "  " + i);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        // 启动子进程
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                MyThread4 th = new MyThread4("joined thread");
                th.start();
                th.join();
            }
        System.out.println(Thread.currentThread().getName() + "  " + i);
        }
    }
}

输出如下：

image.png

4、interrupt线程中断

public void interrupt(); 中断线程。
public static boolean interrupted(); 是一个静态方法，用于测试当前线程是否已经中断，并将线程的中断状态 清除。所以如果线程已经中断，调用两次interrupted，第二次时会返回false，因为第一次返回true后会清除中断状态。

五、守护线程

线程分为用户线程和守护线程，当用户线程结束，守护线程会被强制终止。GC就是守护线程，默认线程是用户线程，在启动前可设置为守护

参考：
http://www.importnew.com/21136.html