笔记 1 · Thread implement Runnable {}

线程独有

每个线程都有自己的工作内存，内存控制不当会造成数据不一致。
(例如：只有一张票，有三个线程看见了这张票，它们把 票数1，保存到了自己的工作内存，然后开始抢票。
这种情况下，不加线程同步，会出现票是负数的情况)

线程状态 Thread.State

NEW
尚未启动的线程处于此状态。

RUNNABLE
在Java虚拟机中执行的线程处于此状态。

BLOCKED
被阻塞 等待监视器锁定的线程处于此状态。

WAITING
正在等待另一个线程执行特定动作的线程处于此状态。

TIMED WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

TERMINATED
已退出的线程处于此状态。

构造方法

public Thread();

• 分配新的线程对象。自动生成的线程名称的格式为“Thread-”+n，其中n是整数。

public Thread(String name);

• 分配新的线程对象。可设置新线程的名称

public Thread(Runnable target);

• 分配新的线程对象。自动生成的线程名称的格式为“Thread-”+n，其中n是整数。
• 参数：target
• 此线程启动时调用其run方法的对象。如果为null，则该类运行方法不执行任何操作。

public Thread(Runnable target, String name);

• 分配新的线程对象。
• 参数：
• 1、此线程启动时调用其run方法的对象。如果为null，则该类运行方法不执行任何操作。
• 2、可设置新线程的名称

public ...(....);

• 省略其他4个构造方法

方法

final native boolean isAlive();

• 如果线程已启动但尚未终止，则该线程是活动的。返回 true；否则为false。

final void setPriority(int newPriority) {…};

• 设置线程的优先级，范围从1 - 10；
• 优先级的设定建议在 start() 调度前。
• 优先级低只是意味着获得调度的概率低。这都要看CPU的调度情况。

final void setDaemon(boolean on) {…};

• 默认为false 用户线程。入参为 true 则设置为 守护线程。
• 虚拟机必须确保 用户线程 执行完毕。例如：Main。
• 虚拟机不用等待 守护线程 执行完毕。例如：CG垃圾回收。
• 必须在线程启动之前调用此方法。

final void join() throws InterruptedException { join(0); }

• 等待此线程死亡的时间最多为毫秒。超时值为0表示永远等待。

final synchronized void join(long millis) {…};

• 方法会阻塞调用此方法的线程，直到线程执行完毕后才会被唤醒。
• 这并不影响同一时刻处在运行状态的其他线程。
• 常用于主线程需要用到子线程的处理结果的情况。

static native void sleep(long millis) throws InterruptedException;

• 使当前执行的线程休眠（暂时停止执行）指定的毫秒数.当前线程陷入阻塞状态。
• sleep时间到达后线程进入 就绪状态。
• sleep可以模拟网络延迟、倒计时等。
• sleep不会释放锁

static native void yield();

• 线程礼让，让当前正在执行的线程暂停，但不阻塞
• 将线程从 运行状态 转为 就绪状态
• 让cpu重新调度，礼让不一定成功！看CPU心情
  

setPriority()

线程优先级并不是一种直观的机制，通过修改线程优先级所带来的的效果通常也不明显。当提高某个线程的优先级时，可能不会起到任何作用，或者也可能使得某个线程的调度优先级高于其他线程，从而导致饥饿。
通常，我们尽量不要改变线程的优先级。只要改变了线程的优先级，程序的行为就将与平台相关，并且会导致发生饥饿问题的风险。你经常能发现某个程序会在一些奇怪的地方调用Thread.sleep 或 Thread.yield，这是因为该程序试图克服优先级调整问题或效应性问题，并试图让低优先级的线程执行更多的时间。
Thread.yield(以及Thread.sleep(O)的语义都是未定义的[JLS 17.9])。JVM既可以将它们实现为空操作，也可以将它们视为线程调度的参考。

yield() 案例

class TestYield implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "线程结束执行");
    }

    public static void main(String[] args) {
        TestYield testYield = new TestYield();
        new Thread(testYield, "a").start();
        new Thread(testYield, "b").start();
    }
}

	// 输出结果
	【礼让成功：】					【礼让失败】
	a线程开始执行					a线程开始执行
	b线程开始执行					a线程结束执行
	a线程结束执行					b线程开始执行
	b线程结束执行					b线程结束执行

线程停止 案例

不推荐使用JDK提供的stop()、destroy()方法。【已废弃】
推荐通过标志位的方法，让线程自己停下来。

class TestStop implements Runnable {
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run .. thread" + i++);
        }
    }

    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 10000; i++) {
            System.out.println("main " + i);
            if (i == 9000){
                // 切换标志位，让线程停止
                testStop.stop();
                System.out.println("线程停止");
            }
        }
    }
}

join() 案例

class AThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始执行");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "执行结束");
    }
}

class Test {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + "开始执行");
        Thread ta = new Thread(new AThread(), "子线程");
        ta.start();
        try {
            ta.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "执行结束");
    }
    // 执行顺序 【不加join()】       【加了join()】
    //         main开始执行         main开始执行
    //         main执行结束         子线程开始执行
    //         子线程开始执行        子线程执行结束
    //         子线程执行结束        main执行结束

}