Java 线程

 // TODO 线程
        // Thread是线程类
        // currentThread 方法用于获取当前运行的线程
        // getName 方法用于获取线程的名称
        // main 方法运行在main线程中
        System.out.println(Thread.currentThread().getName());

        // TODO 创建线程
        //Thread t = new Thread();
        MyThread t = new MyThread();

        // TODO 启动线程
        t.start();

    }
}
// TODO 声明自定义线程类
class MyThread extends Thread {
    // 重写运行指令

    @Override
    public void run() {
        System.out.println("MyThread : " + Thread.currentThread().getName());
    }
}

 // TODO 线程 - 执行方式 （串行 ，并发）
        //  串行执行 : 多个线程连接成串，然后按照顺序执行
        //  并发执行 : 多个线程是独立的，谁抢到了CPU的执行权，谁就能执行

        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();

        t1.start();
        // 将线程连接成串
        t1.join();

        t2.start();
        t2.join();

        System.out.println("main 线程执行完毕");
    }
}
// TODO 第一个线程
class MyThread1 extends Thread {
    // 重写运行指令

    @Override
    public void run() {
        System.out.println("MyThread-1 : " + Thread.currentThread().getName());
    }
}
// TODO 第二个线程
class MyThread2 extends Thread {
    // 重写运行指令

    @Override
    public void run() {
        System.out.println("MyThread-2 : " + Thread.currentThread().getName());
    }
}

       // TODO 线程 - 休眠
        // 休眠3秒钟
        while (true) {
            Thread.sleep(1000);
            System.out.println("main线程执行完毕");
        }

    MyThread3 t3 = new MyThread3();
//        t3.start();
//
//        MyThread4 t4 = new MyThread4();
//        t4.start();

//        MyThread5 t5 = new MyThread5("t5");
//        MyThread5 t55 = new MyThread5("t55");
//
//        t5.start();
//        t55.start();

        // TODO 构建线程对象时，可以只把逻辑传递给这个对象
        //      传递逻辑时，需要遵循规则 ： （） -> { 逻辑 }
//        Thread t6 = new Thread( () -> {
//            System.out.println(" 线程执行1 ");
//        } );
//
//        t6.start();
//
//        Thread t7 = new Thread( () -> {
//            System.out.println(" 线程执行2 ");
//        } );
//
//        t7.start();

        // TODO 构建线程对象时，可以传递实现了Runnable接口的对象,一般使用匿名类
        Thread t8 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(" 线程执行 t8");
            }
        });
        t8.start();

        System.out.println("main线程执行完毕");
    }
}
// TODO 自定义线程
// 1.继承线程类（父类）
// 2.重写run方法
class MyThread3 extends Thread {
    @Override
    public void run() {
        System.out.println("t3 线程执行");
    }
}
class MyThread4 extends Thread {
    @Override
    public void run() {
        System.out.println("t4 线程执行");
    }
}
class MyThread5 extends Thread {
    private String threadName;
    public MyThread5( String name ) {
        threadName = name;
    }
    @Override
    public void run() {
        System.out.println(threadName + " 线程执行");
    }
}

  // TODO 线程 - 线程池
        // 所谓的线程池，其实就是线程对象的容器
        // 可以根据我们的需要，在启动时，创建一个或者多个线程对象
        // Java中有4种比较常见的线程池
        // 1.创建固定数量的线程对象
        //   ExecutorService是线程服务对象
        //ExecutorService executorService = Executors.newFixedThreadPool(3);
        // 2.根据需求动态创建线程
        //ExecutorService executorService = Executors.newCachedThreadPool();
        // 3.单一线程
        //ExecutorService executorService = Executors.newSingleThreadExecutor();
        // 4.定时调度线程
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);



        for (int i = 0; i < 5; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }

// wait & sleep
// 1.名字
//   wait ： 等待
//   sleep ： 休眠
// 2.从属关系
//    wait ： Object ，成员方法
//    sleep ： Thread ， 静态方法
// 3.使用方式
//   wait ： 只能使用在同步代码中
//   sleep ： 可以在任意地方使用
// 4.阻塞时间
//   wait ： 超时时间（会发生错误）
//   sleep ： 休眠时间（不会发生错误）
// 5.同步处理
//   wait ： 如果执行wait方法，那么其他线程有机会执行当前的同步操作
//   sleep ： 如果执行sleep方法，那么其他线程有没有机会执行当前的同步操作

    // synchronized - 同步关键字
        // 多个线程访问同步方法时，只能一个一个访问，同步操作
        // new Hashtable<>();
        // synchronized 关键字还可以修饰代码块，称之为同步代码块
        /*
           synchronized（ 用于同步对象 ） {
               处理逻辑
           }

         */
        Num num = new Num();

        User user = new User(num);
        user.start();

        Bank bank = new Bank(num);
        bank.start();

    }
}
class Num {

}
class Bank extends Thread  {
    private Num num;
    public Bank  ( Num num ) {
        this.num = num;
    }
    public void run () {
        synchronized ( num ) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("9:00,开门，开始叫好");
            num.notifyAll();
        }
    }
}
class User extends Thread {
//    public synchronized void test() {
//
//    }
    private Num num;
    public User ( Num num ) {
        this.num = num;
    }
    public void run () {
        synchronized ( num ) {
            System.out.println("我是号码1，银行还没开门，我需要等一会");
            try {
                num.wait();
            } catch ( InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("叫到我号了，该我办业务了。");
        }

 // 所谓线程安全问题，其实就是多个线程在并发执行时，修改了共享内存中共享对象的属性，导致的数据冲突问题
        User7 user = new User7();

        Thread t1 = new Thread(()->{
            user.name = "zhangsan";
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(user.name);
        });
        Thread t2 = new Thread(()->{
            user.name = "lisi";
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(user.name);
        });
        t1.start();
        t2.start();

        System.out.println("main线程执行完毕");



    }
}
class User7 {
    public String name;
}