实现方式

1. 通过Thread类

1. 继承Thread类，重写run方法。run是线程执行体
2. 通过继承类对象，调用Thread的start方法

2. 通过Runnable接口

1. 实现Runnable接口，重写run方法。run是线程执行体
2. 将实现Runnable接口的类对象作为参数传入Thread，创建Thread对象
3. 调用Thread对象的start方法

3. 通过Callable接口

线程状态

线程方法

• setPriority(int newPriority)：更改线程的优先级
• static void sleep(long millis)：指定毫秒数内让当前执行的线程休眠
• void join：等待线程终止
• static void yield()：暂停当前执行的线程对象，执行其他进程
• void interrupt()：中断线程。（建议不用）
• boolean isAlive()：测试线程是否处于活动状态

1. 线程停止

1. 建议线程正常停止。利用次数，不建议死循环
2. 建议使用标志位
3. 不要使用stop或destory等过时或者JDK不建议使用的方法

以下的写法并不安全，只是演示一下

2. 线程休眠sleep

1. sleep(time)：指定当前线程阻塞的毫秒数
2. sleep存在异常InterruptedException
3. sleep时间达到后，线程进入就绪状态
4. sleep可以模拟网络延时，倒计时等
5. 每个对象都有一个锁，sleep不会释放锁

3. 线程礼让yield

1. 让线程从运行状态转为就绪状态
2. 礼让不一定成功

4. 线程强制执行join

1. 想象为插队
2. join之后，其他线程被阻塞，直到该线程执行完
3. 需要抛出InterruptedException异常

5. 线程状态观测getState

线程状态包括

• NEW：尚未启动
• RUNNABLE：在Java虚拟机中执行的线程处于该状态
• BLOCKED：被阻塞等待监视器锁定的线程处于该状态
• WAITING：正等待另一个线程执行特定动作的线程处于该状态
• TIMED_WAITING：正等待另一个线程执行动作达到指定等待时间的线程处于此状态
• TERMINATED：已退出的线程处于此状态

6. 线程优先级

1. Java提供线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程执行
2. 线程优先级用数字表示，范围是1到10
3. getPriority()获得优先级
4. setPriority()设置优先级

• MIN_PRIORITY = 1：最小优先级
• MAX_PRIORITY = 10：最大优先级
• NORM_PRIORITY = 5：默认优先级

1. 优先级低只是意味着获得调度的概率低，并不是不会被调用，都要看CPU调度
2. 优先级的设定建议在start之前

守护线程（daemon

1. 线程分为用户线程和守护线程，后者例如：后台记录操作日志、监控内存、垃圾回收等待
2. 虚拟机必须确保用户线程执行完毕
3. 虚拟机不用等待守护线程执行完毕
4. 设置线程为守护线程setDaemon(true)

线程同步 TODO

解决多个线程操作同一个资源的问题

1. 访问时加入锁机制，synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁
2. 一个线程持有锁会导致其他所有需要此锁的线程挂起
3. 多线程竞争下，加锁、释放锁会导致较多上下文切换和调度延时，引起性能问题
4. 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

⚠️ synchronized默认锁this。有些时候需要同步块

• 同步块：synchronized(Obj) {}，Obj是同步监视器，可以是任何对象，但是推荐使用共享资源作为同步监视器

线程死锁

1. 多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，导致多个线程都在等待对方释放资源，都停止执行。
2. 某一个同步块同时拥有“两个以上对象的锁”时，就可能发生死锁

死锁产生条件：

1. 互斥条件：一个资源每次只能被一个进程使用
2. 请求与保持条件：一个进程因为请求资源阻塞时，对已获得的资源保持不放
3. 不剥夺条件：进程已获得的资源，在没有使用完之前，不能强行剥夺
4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

public class TestDeadLock {
    public static void main(String[] args) {
        MakeUp g1 = new MakeUp(0, "syb");
        MakeUp g2 = new MakeUp(1, "yyj");
        g1.start();
        g2.start();
    }
}

class Mirror{}
class Table{}
class MakeUp extends Thread{
    static final Mirror mirror = new Mirror();
    static final Table table = new Table();
    int choice;
    String name;
    MakeUp(int choice, String name){
        this.choice = choice;
        this.name = name;
    }
    @Override
    public void run(){
        makeup();
    }
    public void makeup(){
        if(choice == 0){
            System.out.println("请求Mirror的锁");
            synchronized (mirror){
                System.out.println("获得Mirror的锁");
                System.out.println("请求Table的锁");
                synchronized (table){   // 有一把锁，还请求另一把，可能死锁
                    System.out.println("获得Table的锁");
                }
            }
        }else{
            System.out.println("请求Table的锁");
            synchronized (table){
                System.out.println("获得Table的锁");
                System.out.println("请求Mirror的锁");
                synchronized (mirror){  // 有一把锁，还请求另一把，可能死锁
                    System.out.println("获得Mirror的锁");
                }
            }
        }
    }
}

Lock锁（可重入锁

1. 从JDK 5.0开始，Java提供更强大的线程同步机制，可以显式定义同步锁对对象实现同步
2. Lock提供对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源前需要先获得Lock对象
3. ReentrantLock类实现了Lock，拥有与synchronized相同的并发性和内存语义，可以显式加锁lock()、释放锁unlock()

线程协作 TODO

Java提供以下方法解决进程之间的通信问题。均为Object类的方法，只能在同步方法或同步代码块中使用，否则会抛出异常IllegalMonitorStateException

• wait()：表示线程一直等待，直到其他线程通知。与sleep不同的是，会释放锁
• wait(long timeout)：指定等待的毫秒数
• notify()：唤醒一个等待的进程
• notifyAll()：唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度

线程池

提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁、实现重复利用

1. JDK 5 提供线程池相关API：ExectuorService和Executors
2. 真正的线程池接口：ExecutorService。常见子类ThreadPoolExecutor
3. Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

• void execute(Runnable command)：执行命令，没有返回值
• <T> Future<T> submit(Callable<T> task)：执行任务，有返回值
• void shutdown()：关闭连接池