2021Java并发编程<线程基础>

1、并发编程的优点

• 充分利用多核cup
• 提成系统的性能

2、并发编程的三要素

• 原子性
• 一致性
• 有序性

3、并发和并行有什么区别
并发：cup来回切换做多件事
并行：多个cup做多件事

4、什么是线程死锁
死锁是指两个或两个以上的进程（线程）在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象。
模拟线程死锁

public class DeadLockDemo {
    private static Object resource1 = new Object();//资源 1
    private static Object resource2 = new Object();//资源 2

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (resource1) {
                System.out.println(Thread.currentThread() + "get resource1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource2");
                synchronized (resource2) {
                    System.out.println(Thread.currentThread() + "get resource2");
                }
            }
        }, "线程 1").start();

        new Thread(() -> {
            synchronized (resource2) {
                System.out.println(Thread.currentThread() + "get resource2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread() + "waiting get resource1");
                synchronized (resource1) {
                    System.out.println(Thread.currentThread() + "get resource1");
                }
            }
        }, "线程 2").start();
    }
}

5、创建线程的方式

• 继承 Thread 类
• 实现 Runnable 接口
• 实现 Callable 接口
• 使用 Executors 工具类创建线程池

public class MyTest {
    public static void main(String[] args) {
        // 方式一 继承Thread
        new MyThread1().start();

        // 方式二 实现 Runnable 接口
        MyThread2 myThread2 = new MyThread2();
        new Thread(myThread2).start();

        // 方式三 实现 Callable 接口
        MyThread3 myThread3 = new MyThread3();
        FutureTask<Boolean> futureTask = new FutureTask<>(myThread3);
        new Thread(futureTask).start();

        // 方式四 使用 Executors 工具类创建线程池
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        executorService.submit(myThread2);

        executorService.submit(myThread3);

        executorService.execute(myThread2);
    }
}

public class MyThread1 extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread 实现多线程");
    }
}

public class MyThread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable 实现多线程");
    }
}

public class MyThread3 implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        System.out.println("实现Callable 实现多线程");
        return true;
    }
}

输出结果.png
6、说一下 runnable 和 callable 有什么区别
相同点：

• 都可以通过实现接口的方式实现多线程
• 都采用Thread.start()启动线程

不同点

• Runnable 接口 run 方法无返回值；Callable 接口 call 方法有返回值
• Runnable 接口 run 方法只能抛出运行时异常，且无法捕获处理；Callable 接口 call 方法允许抛出异常，可以获取异常信息

7、