多线程 笔记

并发编程三要素？

1）原子性

原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。

2）可见性

可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。

3）有序性

有序性，即程序的执行顺序按照代码的先后顺序来执行。

实现可见性的方法有哪些？

synchronized或者Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见性

创建线程的有哪些方式？

1）继承Thread类创建线程类

2）通过Runnable接口创建线程类

3）通过Callable和Future创建线程

4）通过线程池创建

什么是线程池？有哪几种创建方式？

线程池就是提前创建若干个线程，如果有任务需要处理，线程池里的线程就会处理任务，处理完之后线程并不会被销毁，而是等待下一个任务。由于创建和销毁线程都是消耗系统资源的，所以当你想要频繁的创建和销毁线程的时候就可以考虑使用线程池来提升系统的性能。
java 提供了一个 java.util.concurrent.Executor接口的实现用于创建线程池。

单例模式的线程安全性

1）饿汉式单例模式的写法：线程安全

2）懒汉式单例模式的写法：非线程安全

3）双检锁单例模式的写法：线程安全

并发与并行

线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果

public class Demo4 {
    /**
     * 缓存线程池（长度无限制）
     * 任务加入后的执行流程
     * 1.判断线程池是否存在空闲线程
     * 2.存在则使用
     * 3.不存在 则创建线程 并放入线程池，然后使用
     * @param args
     */
//    public static void main(String[] args) {
//        //指挥线程池中执行新的任务
//        ExecutorService service = Executors.newCachedThreadPool();
//        service.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"锄禾日当午1");
//            }
//        });
//        service.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"锄禾日当午2");
//            }
//        });
//        service.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"锄禾日当午3");
//            }
//        });
//
//        try {
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//        service.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"锄禾日当午");
//            }
//        });
//    }

    /**
     * 定长线程池
     * （长度是指定数值）
     * 任务加入后实行流程
     * 1.判断线程池是否存在空闲线程
     * 2.存在则使用
     *  3.不存在空闲线程且线程池未满的形况下 则创建线程 并放入线程池，然后使用
     *  4.不存在空闲线程 且线程池已满的情况下，则等待线程池存在空闲线程
     */
//    public static void main(String[] args) {
//        ExecutorService service = Executors.newFixedThreadPool(3);
//        service.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"锄禾日当午1");
//
//                try {
//                    Thread.sleep(3000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
//        });
//        service.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"锄禾日当午2");
//
//                try {
//                    Thread.sleep(3000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
//        });
//        service.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"锄禾日当午3");
//                try {
//                    Thread.sleep(3000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//
//            }
//        });
//        service.execute(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println(Thread.currentThread().getName()+"锄禾日当午5");
//            }
//        });
//    }

                 /**
            *           单程线程池
                  *           1.判断线程池的那个线程是否空闲
                  *           2.空闲则使用
                  *           3.不空闲则等待 池中的单个线程空闲后 使用
               */
//       public static void main(String[] args) {
//            ExecutorService service = Executors.newSingleThreadExecutor();
//            service.execute(new Runnable() {
//                @Override
//                public void run() {
//                    System.out.println(Thread.currentThread().getName()+"锄禾日当午1");
//                }
//            });
//           service.execute(new Runnable() {
//               @Override
//               public void run() {
//                   System.out.println(Thread.currentThread().getName()+"锄禾日当午2");
//               }
//           });
//           service.execute(new Runnable() {
//               @Override
//               public void run() {
//                   System.out.println(Thread.currentThread().getName()+"锄禾日当午3");
//               }
//           });
//           service.execute(new Runnable() {
//               @Override
//               public void run() {
//                   System.out.println(Thread.currentThread().getName()+"锄禾日当午4");
//               }
//           });
//       }

    /**
     * lambda表达式
     * 保留参数 -> 保留方法体
     */
    public static void main(String[] args) {
        Thread t = new Thread(() ->{
            System.out.println("shuaige");
        });
        t.start();
    }
}