1.1多线程
        Thread：
                void setName(String name)设置线程名称
                String getName（）获取线程名称
                start()开启新的线程，并在新线程中调用run方法

                static void sleep(long millis)对应线程睡眠指定毫秒值
                static Thread currentThread（）获取当前正在执行对应代码的线程

        线程的开启方式1：
                1.定义类继承Thread
                2.重写run方法
                3.创建Thread的之类对象
                4.调用start方法开启线程
        线程的开启方式2：
                1.定义一个类，实现Runnnable接口
                2.重写接口中的run方法
                3.创建Runnable的实现类对象
                4.创建一个Thread对象，并把Runnable的实现类对象当作构造的参数传递进去
                5.调用start方法开启线程

        对两种开启线程方式的比较：
        实现方式1：
                实现起来相对简单
        实现方式2：
                耦合性：代码和代码之间的关联性
                实现方式2：将在线程中执行的代码和线程开启，设置线程名称功能分离
         编程的原则：高内聚，低耦合

         实现Runnable接口创建多线程程序的好处：
                1.避免了单继承的局限性
                       一个类只能继承一个类，类继承了Thread类就不能继承其他的类了
                       实现了Runnable接口，还可以继承其他类，实现其他的接口
                2.增强了程序的扩展性，降低了程序的耦合性（解耦）
                        实现了Runnable接口的方式，把设置线程任务和开启线程任务进行了分离（解耦）
                        实现类中，重写了run方法：用来设置线程任务
                        创建Thread类对象，调用Start方法：用来开启程序
         用匿名内部类改进代码
                匿名内部类：
                        格式：
                                new 父类/福接口（）{
                                        重写父类的方法
                                        };
                                匿名内部类本质就说父类/父接口的子类对象
                                将定义类和创建对象放在一起了

       *已经开启的线程不能被再次开启，

2.1同步技术：
        1.同步代码块：
                格式：
                        synchronized（锁对象）{
                            需要被同步的代码（被上锁的代码）
                        }

                锁对象：可以是任意对象 举例：new Object
                        要求：对多线程来说，锁对象只能有一个

                        this  当当前类只有一个对象，此时使用this也可以
                        当前类.class/类对象，是独一无二的，也可以
                执行流程：
                        三个线程会抢夺锁对象，
                        如果其中有一个线程抢到了锁，这个时候整个同步代码块只能有一个线程执行
                        其他线程哪怕有CPU的执行权，都不能进入同步中
                        当抢到锁的线程执行完整个同步代码块，其他线程才有可能抢到锁

        2.同步方法
                在方法的修饰符上加上一个synchronized关键字
                整个方法都被同步了，某一个时刻只有一个线程在方法种执行

                同步方法有默认的锁对象
                        非静态同步方法：this
                        静态同步方法：

        同步方法3：
                lock锁：
                        lock：
                                lock（）获取锁
                                unlock（）释放锁
                                实现等待唤醒：
                                        Condition c=lock.newCondition();
                                        c.await()相当于等待
                                        c.signal()相当于唤醒

1.1多线程
        Thread：
                void setName(String name)设置线程名称
                String getName（）获取线程名称
                start()开启新的线程，并在新线程中调用run方法

                static void sleep(long millis)对应线程睡眠指定毫秒值
                static Thread currentThread（）获取当前正在执行对应代码的线程

        线程的开启方式1：
                1.定义类继承Thread
                2.重写run方法
                3.创建Thread的之类对象
                4.调用start方法开启线程
        线程的开启方式2：
                1.定义一个类，实现Runnnable接口
                2.重写接口中的run方法
                3.创建Runnable的实现类对象
                4.创建一个Thread对象，并把Runnable的实现类对象当作构造的参数传递进去
                5.调用start方法开启线程

        对两种开启线程方式的比较：
        实现方式1：
                实现起来相对简单
        实现方式2：
                耦合性：代码和代码之间的关联性
                实现方式2：将在线程中执行的代码和线程开启，设置线程名称功能分离
         编程的原则：高内聚，低耦合

         实现Runnable接口创建多线程程序的好处：
                1.避免了单继承的局限性
                       一个类只能继承一个类，类继承了Thread类就不能继承其他的类了
                       实现了Runnable接口，还可以继承其他类，实现其他的接口
                2.增强了程序的扩展性，降低了程序的耦合性（解耦）
                        实现了Runnable接口的方式，把设置线程任务和开启线程任务进行了分离（解耦）
                        实现类中，重写了run方法：用来设置线程任务
                        创建Thread类对象，调用Start方法：用来开启程序
         用匿名内部类改进代码
                匿名内部类：
                        格式：
                                new 父类/福接口（）{
                                        重写父类的方法
                                        };
                                匿名内部类本质就说父类/父接口的子类对象
                                将定义类和创建对象放在一起了

       *已经开启的线程不能被再次开启，

2.1同步技术：
        1.同步代码块：
                格式：
                        synchronized（锁对象）{
                            需要被同步的代码（被上锁的代码）
                        }

                锁对象：可以是任意对象 举例：new Object
                        要求：对多线程来说，锁对象只能有一个

                        this  当当前类只有一个对象，此时使用this也可以
                        当前类.class/类对象，是独一无二的，也可以
                执行流程：
                        三个线程会抢夺锁对象，
                        如果其中有一个线程抢到了锁，这个时候整个同步代码块只能有一个线程执行
                        其他线程哪怕有CPU的执行权，都不能进入同步中
                        当抢到锁的线程执行完整个同步代码块，其他线程才有可能抢到锁

        2.同步方法
                在方法的修饰符上加上一个synchronized关键字
                整个方法都被同步了，某一个时刻只有一个线程在方法种执行

                同步方法有默认的锁对象
                        非静态同步方法：this
                        静态同步方法：

        同步方法3：
                lock锁：
                        lock：
                                lock（）获取锁
                                unlock（）释放锁
                                实现等待唤醒：
                                        Condition c=lock.newCondition();
                                        c.await()相当于等待
                                        c.signal()相当于唤醒