JAVA EE初阶 2：多线程-初阶

1.认识线程（Thread）

1.1 概念

1.2 创建线程(lambda最常用)

1.2.1 方法1 - 继承Thread类

【 Ctrl + C 取消终止】

1.2.2 方法2 - 实现Runnable接口

1.2.3 总结

1.2.4 匿名内部类

2.Thread类及常见方法

2.1 构造方法

2.2 常见属性

2.3 启动一个线程 start()

调用start方法，才真的在操作系统的底层创建出⼀个线程。

2.4 中断一个线程

java 复制代码

package thread;

public class Demo7 {

    private static boolean flag = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {   
            while(flag){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });

        t.start();
        System.out.println("hello main");
        Thread.sleep(3000);

        flag = false;
        System.out.println("让 t 线程终止");

    }

}

java 复制代码

package thread;

public class Demo7 {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {   
            while(Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });

        t.start();
        System.out.println("hello main");
        Thread.sleep(3000);

        t.interrupt();
        System.out.println("t 线程的中断标志位：" + t.isInterrupted());


    }

}

2.5 等待一个线程 join()

有时，我们需要等待一个线程完成它的工作后，才能进的下⼀步工作，这时我们需要⼀个方法明确等待线程的结束。

主线程等待代码

java 复制代码

package thread;

public class Demo7 {
    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(() -> {
            for(int i = 0; i < 5; i++){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    //e.printStackTrace();
                    break;
                }
            }
        });

        System.out.println("主线程开始");

        t.start();
        System.out.println("主线程等待之前");
        t.join();
        System.out.println("主线程等待之后");
        
        System.out.println("主线程结束");


    }
}

t 线程等待代码

java 复制代码

package thread;

public class Demo7 {
    public static void main(String[] args) throws InterruptedException {

        Thread mainThread = Thread.currentThread();

        Thread t = new Thread(() -> {
                try {
                    System.out.println("t 线程等待之前");
                    mainThread.join();
                    System.out.println("t 线程等待之后");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            
        });

        t.start();

        for(int i = 0; i < 3; i++){
            System.out.println("hello main");
            Thread.sleep(1000);
        }


    }
}

2.6 获取当前线程引用

2.7 休眠当前线程

3.线程的状态

线程的状态是⼀个枚举类型 Thread.State

4.多线程带来的的风险-线程安全(重点！)

4.1 概念例子

4.2 线程不安全的原因

5.死锁（重点）

java 复制代码

    Object lock1 = new Object();
    Object lock2 = new Object();
    Thread t1 = new Thread() {
        @Override
        public void run() {
            synchronized (lock1) {
                synchronized (lock2) {
                    // do something...
                }
            }
        }
    };
    t1.start();
    Thread t2 = new Thread() {
        @Override
        public void run() {
            synchronized (lock2) {
                synchronized (lock1) {
                    // do something...
                }
            }
        }
    };
    t2.start();

不会产生环路等待的代码:约定好先获取lock1,再获取lock2,就不会环路等待。

java 复制代码

    Object lock1 = new Object();
    Object lock2 = new Object();
    Thread t1 = new Thread() {
        @Override
        public void run() {

            synchronized (lock1) {
                synchronized (lock2) {
                    // do something...
                }
            }
        }
    };
    t1.start();
    Thread t2 = new Thread() {
        @Override
        public void run() {
            synchronized (lock1) {
                synchronized (lock2) {
                    // do something...
                }
            }
        }
    };
    t2.start();