多线程笔记：多线程基础 - 1

1.线程的创建和启动方式：
    1.自定义类，让其继承Thread并重写run()方法，创建此类的对象。调用start()方法启动
        public class MyThread extends Thread {    //自定义线程类
            @Override
            public void run() {
                。。。
            }
        }
        
        MyThread t1 = new MyThread();        //创建
        t1.start();        //启动
    2.自定义类实现runnable接口，实现run()方法，创建Thread对象并传入这个实现类。调用start()方法启动
        public class MyThread2 implements Runnable {    //实现类
            @Override
            public void run() {
                。。。
            }
        }
        
        MyRunnable r = new MyRunnable();    
        Thread t1 = new Thread(r);    //创建线程
        t1.start();        //    启动  
        
        注意：只有Thread对象才有start()方法用于启动线程
        
        
2.线程之间数据共享
    1.创建runnable实现类或继承Thread,重写run()方法：
        public class MyRunnable implements Runnable {
            private int count = 100;        //要共享的变量
            @Override
            public void run() {
                while (count > 0) {
                    try {
                        Thread.sleep(100);
                        count --;
                        System.out.println(count);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        
        
    2.创建多个线程，
        MyRunnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
        
        此时t1,t2共享了变量count
    
    注意：这里有线程安全问题
    
3.Thread的方法：
    Thread.currentThread()        //静态方法，获取当前正在运行线程（执行此代码的线程）对象
    isAlive()     //检查线程是否处于活动状态，活动状态：线程已经启动且尚未停止
    Thread.sleep()        //静态方法，让当前线程（执行此代码的线程）休眠
    getId()      //获取线程的唯一标识
    
    
    例子：
        MyRunnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        System.out.println(Thread.currentThread().getName());    
        System.out.println(Thread.currentThread().getId());
        System.out.println(t1.getName());
        System.out.println(t1.getId());
        Thread.sleep(1000);
        System.out.println(t1.isAlive());
        t1.start();
        System.out.println(t1.isAlive());
        
        运行结果：
            main
            1
            Thread-0
            11
            false
            true
    
4.线程的停止
    1. interrupt(); 用于停止线程的方法    //做了一件事：将线程停止状态的值置为了true
    
        注意！！这里调用interrupt()方法停止线程，所谓停止线程并不是说线程执行完这个方法后就不执行了。调用此方法
        仅仅是改变了线程的状态。线程中有一个标识线程是否停止的状态值。interrupt()方法将此值置为true,线程将继续往下执行。
        
        例子：
            System.out.println("执行前");
            Thread.currentThread().interrupt();
            System.out.println("执行后");    
            
            运行结果：
                执行前
                执行后        //调用interrupt方法后，线程依然在执行
        
        
    2.查看停止状态的方法：
        1. isInterrupted()    //用于查看线程状态，返回boolean
            
            例子：
                System.out.println("执行前");
                boolean status1 = Thread.currentThread().isInterrupted();
                System.out.println(status1);

                Thread.currentThread().interrupt();

                boolean status2 = Thread.currentThread().isInterrupted();
                System.out.println(status2);
                System.out.println("执行后");
    
                运行结果：
                    执行前
                    false        //执行前为false
                    true        //执行后为true
                    执行后
                    
        2.interrupted()        //也是用于查看线程状态，为静态方法
            例子：
                System.out.println("执行前");
                System.out.println(Thread.interrupted());
                
                Thread.currentThread().interrupt();
                
                System.out.println(Thread.interrupted());    //返回线程状态，并重置状态为false
                System.out.println(Thread.interrupted());    //再次调用返回false,因为interrupted()返回线程状态的同时，会重置线程的状态为false
                System.out.println("执行后");
    
                运行结果：
                    执行前
                    false
                    true
                    false
                    执行后
                    
        注意：线程的状态初始值为false, 调用start()方法启动线程前是false, 执行完后，如果是true会被重置为false
            因此，此状态值是在线程执行过程中才有意义。
            
    3.两个方法的区别：
        1.isInterrupted()为非静态方法，interrupted()为静态方法。isInterrupted()查看的是调用此方法的线程的状态
            interrupted()查看的是执行当前行代码的线程的状态
        2.isInterrupted()不会重置状态为false,interrupted()调用完会重置状态为false
        
        
    
    
    4.sleep()方法与线程停止    
        当线程停止状态为true时，调用sleep会抛异常
        调用sleep()进行线程休眠，在休眠过程中，如果线程停止状态由false变为true时,也会抛异常
    
        例子：
            Thread.sleep(1000);
            System.out.println("执行前，状态：" + Thread.currentThread().isInterrupted());
            Thread.currentThread().interrupt();
            System.out.println("执行后，状态：" + Thread.currentThread().isInterrupted());
            Thread.sleep(1000);
    
            运行结果：
                执行前，状态：false
                执行后，状态：true
                java.lang.InterruptedException: sleep interrupted
                    at java.lang.Thread.sleep(Native Method)
                    at com.huawei.controller.ThreadController.main(ThreadController.java:31)
    
            
            public class MyRunnable implements Runnable {
                private int count = 100;
                @Override
                public void run() {
                    try {
                        System.out.println("线程执行");
                        Thread.sleep(1000);        //休眠
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            
            MyRunnable r = new MyRunnable();
            Thread t1 = new Thread(r);
            t1.start();
            t1.interrupt();    //线程休眠时，改变状态为true
    
            运行结果：
                线程执行
                java.lang.InterruptedException: sleep interrupted
                    at java.lang.Thread.sleep(Native Method)
                    at com.huawei.thread.MyRunnable.run(MyRunnable.java:18)
                    at java.lang.Thread.run(Thread.java:745)
    
5.让线程真正停止的方法，即不是改变停止状态，而是停止执行的方法：stop()  //暴力终止线程执行，为已过时的方法    
    例子：
        public class MyRunnable implements Runnable {
            private int count = 100;
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        System.out.println("线程执行，循环次数：" + (i + 1));
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        MyRunnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        t1.start();
        Thread.sleep(3000);
        t1.stop();
    
        运行结果：
            线程执行，循环次数：1
            线程执行，循环次数：2
            线程执行，循环次数：3        //循环三次后，线程被终止，不再执行  //真正的停止

            Process finished with exit code 0
    
    调用slop()方法终止线程可能造成的问题：
        1.可能使一些清理性的工作得不到完成
        2.终止线程时会释放锁，这种释放是非正常释放，可能造成数据不一致问题。
        
6.不适用stop()完成线程终止：
    采用停止状态进行控制，实现线程终止：如果停止状态为true,则抛出异常，或者使用return停止线程
    
    例子：
    
        public class MyRunnable implements Runnable {
            private int count = 100;
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        System.out.println("线程执行，循环次数：" + (i + 1));
                        Thread.sleep(1000);
                        if (Thread.interrupted()) {        //检查状态
                            throw new InterruptedException();    //如果问停止状态，则抛异常终止代码运行
                            //return;        //或者使用return终止，此时也会抛出InterruptedException异常
                        }
                    }
                } catch (InterruptedException e) {
                    System.out.println("线程终止，进行垃圾清理等工作。。。");        //线程执行停止后进行后续清理等工作
                }
            }
        }
    
        MyRunnable r = new MyRunnable();
        Thread t1 = new Thread(r);
        t1.start();
        Thread.sleep(3000);
        t1.interrupt();        //调用interrupt方法改变停止状态而不是暴力终止