Java030-线程基础

moc

1、简介
进程： 正在运行的程序，是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源，详见入口。
线程： 是进程中的单个顺序控制流，是一条执行路径，线程不能独立存在，依附于进程。
Java程序至少有两个线程：  主线程 + 垃圾回收线程
线程的生命周期：

新建状态:
        使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
就绪状态:
        当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
运行状态:
        如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
阻塞状态:
        如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
        ① 等待阻塞： 运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
        ② 同步阻塞： 线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
        ③ 其他阻塞： 通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
死亡状态:
        一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。
2、线程实现方式1: 继承Thread类
步骤：
        ① 自定义类MyThread继承Thread类；
        ② MyThread类里面重写run()；
        ③ 创建MyThread类的对象，即线程对象；
        ④ 启动线程，调用线程对象的start()方法。
注意：
        ① run():仅仅是封装被线程执行的代码，直接调用是普通方法
        ② start():首先启动了线程，然后再由jvm去调用该线程的run()方法
获取设置线程名：
public static Thread currentThread() ------------>  返回当前正在执行的线程对象
public final String getName()  --------------------->  获取线程的名称        
public final void setName(String name) --------->  设置线程的名称
举例：

// 线程类
public class MyThread extends Thread {        
        public MyThread() {
        }
        
        public MyThread(String name){
                super(name);
        }

        @Override
        public void run() {
                for (int x = 0; x < 20; x++) {
                        System.out.println(x);
                }
        }
}
// 线程测试类
public class MyThreadDemo {
        public static void main(String[] args) {
                // 创建线程对象 --- 无参构造+setXxx()
                MyThread my1 = new MyThread();
                my1.setName("Ubuntu");     //调用方法设置名称
                my1.start();
                
                // 创建线程对象 --- 带参构造方法
                MyThread my2 = new MyThread("Centos");
                my2.start();
                
                System.out.println(Thread.currentThread().getName());
        }
}

3、线程控制
1. 守护线程（后台线程）
守护线程与普通线程的唯一区别是：当JVM中所有的线程都是守护线程的时候，JVM就可以退出了；如果还有一个或以上的非守护线程则不会退出。（以上针对正常退出，调用System.exit必定会立即退出）
方法:   public final void setDaemon(boolean on)

MyThread my3 = new MyThread("RedHat");
my3.setDaemon(true);
my3.start();

2. 线程休眠
Thread类静态方法，让线程进程一定时间的阻塞状态，时间结束后处于就绪状态争夺CPUI执行权。
方法:     public static void sleep(long millis)
3. 线程加入
等待该线程终止，在进行其他线程的执行。
方法:   public final void join()

MyThread my4 = new MyThread("openSuSE");
MyThread my5 = new MyThread("Linux Mint");
my4.start();
try {
        my4.join();
} 
catch (InterruptedException e) {
        e.printStackTrace();
}
my5.start();

4. 线程礼让
Thread类静态方法，暂停当前正在执行的线程对象，并执行其他线程。
让多个线程的执行更和谐，但是不能靠它保证一个线程一次。
方法:   public static void yield()

public class ThreadYield extends Thread {
        @Override
        public void run() {
                for (int x = 0; x < 100; x++) {
                        System.out.println(getName() + ":" + x);
                        Thread.yield();    // 线程礼让
                }
        }
}

5. 中断线程
把线程的状态终止，并抛出一个InterruptedException。
方法:     public void interrupt()

MyThread my6 = new MyThread("Debian");
my6.start();
// 线程超过三秒不醒过来，就中断线程 (最多允许该线程允许3s)
try {
        Thread.sleep(3000);
        my6.interrupt();
} 
catch (InterruptedException e) {
        e.printStackTrace();
}

6. 线程优先级
        ① 每一个 Java 线程都有一个优先级< 默认NORM_PRIORITY（5）>，这样有助于操作系统确定线程的调度顺序。
        ② Java 线程的优先级是一个整数，其取值范围是 1 （Thread.MIN_PRIORITY ） - 10 （Thread.MAX_PRIORITY ）。
        ③ 具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器资源。但是，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。
方法:
public final int getPriority()  --------------------------> 返回线程对象的优先级
public final void setPriority(int newPriority) --------> 更改线程的优先级。

MyThread my7 = new MyThread("Fedora");
MyThread my8 = new MyThread("Solus OS");

System.out.println(my7 .getPriority());
my8.setPriority(2);

my7.start();
my8.start();

4、线程实现方式2: 实现Runnable接口
步骤：
        ① 自定义类MyRunnable实现Runnable接口；
        ② 重写run()方法；
        ③ 创建MyRunnable类的对象；
        ④ 创建Thread类的对象，并把③步骤的对象作为构造参数传递。

// Runnable接口实现类
public class MyRunnable implements Runnable {
        @Override
        public void run() {
                for (int x = 0; x < 100; x++) {
                        // 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用
                        System.out.println(Thread.currentThread().getName() + ":" + x);
                }
        }
}
// Runnable实现类测试
public class MyRunnableDemo {
        public static void main(String[] args) {
                MyRunnable my = new MyRunnable();  // 创建MyRunnable类的对象

                // 创建Thread类的对象，并把③步骤的对象作为构造参数传递                
                Thread t1 = new Thread(my);     // Thread(Runnable target)
                t1.setName("Windows");;
                Thread t2 = new Thread(my, "Linux");   // Thread(Runnable target, String name)

                t1.start();
                t2.start();
        }
}