实战Java高并发程序设计-03 Java线程

概念

线程的生命周期

线程的状态定义在 java.lang.Thread.State 中

NEW

创建状态并未执行，通过start()方法开始线程执行，进入RUNNABLE

RUNNABLE

运行状态

BLOCKED

阻塞状态，如果在执行的过程中遇到了synchronize 关键字标注的同步块，就会进入阻塞状态

WAITING

等待状态，表示线程进入了等待状态，直到notify()方法执行通知后，线程继续进入运行状态
TIMED_WAITING
等待状态，同上一样，只不过加上了一个等待的时间限制.
TERMINATED
终止状态

线程的基本操作

新建线程与启动

主线程

package t;

public class M {

    public static void main(String[] args) {
        Thread t = new Thread(new MyThread());
        //t.start();
        t.run();
        for(int i = 0 ;i < 5 ; i++){
            System.out.println("main : " + i);
        }
    }

}

子线程

package t;

public class MyThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0 ; i < 5 ; i++){
            System.out.println("other : " + i);
        }
    }

}

注意：启动方法时start ，而不是 run 。 如果通过run就是串行话的调用，打印结果永远都是

other : 0
other : 1
other : 2
other : 3
other : 4
main : 0
main : 1
main : 2
main : 3
main : 4

而使用start才是开启线程，打印结果随机产生，是因为线程的执行情况，有时候主线程执行的比较快，也适合子线程执行的比较快

线程终止

正常情况下，线程执行完毕就会终止，不用手动关闭。
但是有时候也会有一些情况下是有例外的，比如线程本身就在一个无限循环里面执行

关闭线程在jdk中提供了一个stop方法，但是这个方法已经过时了，因为这个方法太暴力，直接关闭线程，不管线程是否执行完毕。

线程同步synchronize

//打印类
public class Print {
    public synchronized void prt(){
        for(int i = 0 ; i < 5  ; i++){
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }
}
//线程类
public class Th1 implements Runnable{

    private Print p;

    public Th1(Print p) {
        this.p = p;
    }

    @Override
    public void run() {
        p.prt();
    }
}
//Main方法类
public class M {

    public static void main(String[] args) {

        Print p = new Print();
        new Thread(new Th1(p)).start();
        new Thread(new Th1(p)).start();
    }

}

上面这段代码 直接执行 打印结果 如下，ID并不连续，一会打印线程9 ，一会打印 线程10

Thread-0 : 0
Thread-1 : 0
Thread-0 : 1
Thread-1 : 1
Thread-0 : 2
Thread-1 : 2
Thread-0 : 3
Thread-1 : 3
Thread-0 : 4
Thread-1 : 4

而给 Print类的prt 方法 加上 synchronized 后 发现 打印是非常规律的，一个线程完全打印完毕，才会打印另外一个线程，也意味着 一个线程执行完毕，另外一个线程才能进行执行

等待与通知

在调用wait的时候，线程自动释放其占有的对象锁，同时不会去申请对象锁。当线程被唤醒的时候，它才再次获得了去获得对象锁的权利。
notify唤醒在等待该对象同步锁的线程(只唤醒一个,如果有多个在等待),注意的是在调用此方法的时候，并不
能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级
notifyAll唤醒所有等待的线程

package c;

public class MyThreadFactory {

    public static void main(String[] args) {
        MyThreadFactory factory = new MyThreadFactory();
        factory.startThreadA();
        factory.startThreadB();
        factory.startThreadC();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        factory.startWakenThread();
    }

    public MyThreadFactory() {
    }

    /**
     * 对象锁
     */
    private final Object object = new Object();

    /**
     * 该线程作为一个唤醒线程
     */
    public void startWakenThread() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("唤醒线程开始执行...");
                    // 首先释放线程A
                    quitThreadA();
                }
            }
        });
        t.start();
    }

    /**
     * 启动线程A
     */
    public void startThreadA() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("线程A开始等待...");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程A结束...");
                    // 线程A结束后，暂停2秒释放线程B
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    quitThreadB();
                }
            }
        });
        t.start();
    }

    /**
     * 启动线程B
     */
    public void startThreadB() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("线程B开始等待...");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程B结束...");
                    // 线程B结束后，暂停2秒释放线程C
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    quitThreadC();
                }
            }
        });
        t.start();
    }

    /**
     * 启动线程C
     */
    public void startThreadC() {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (object) {
                    System.out.println("线程C开始等待...");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程C结束...");

                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("所有线程执行完毕！");
                }
            }
        });
        t.start();
    }

    /**
     * 线程A退出等待
     */
    private void quitThreadA() {
        object.notify();
    }

    /**
     * 线程B退出等待
     */
    private void quitThreadB() {
        object.notify();
    }

    /**
     * 线程C退出等待
     */
    private void quitThreadC() {
        object.notify();
    }
}

等待线程结束(join)和谦让(yield)

join表示在两个线程执行的过程中A线程执行某一项工作，B线程执行一项工作依赖A线程执行初始化完毕之后才能开始执行，则可以用的join
yield表示当前线程让出cpu执行，但是让出线程之后不代表这个线程就不执行了，而是由当前线程与其他线程进行资源的抢夺，当前线程能否再次被分配到就是随机的

线程的优先级

/**
* 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;