JAVA多线程（学习笔记）（Thread与Runnable的区别、匿名内部类）

Thread与Runnable的区别

实现Runnable接口创建多线程程序的好处：

1. 避免了单继承的局限性；
   一个类只能有一个父类，类继承了Thread类就不能继承其他的类
   所以实现了Runnable接口，还可以继承其他的类，实现其他的接口。
2. 增强了程序的扩展性，降低了程序的耦合性（解耦）；
   实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）；
   实现类中，重写了run方法：用来设置线程任务；
   创建Thread类对象，调用start方法：用来开启新线程。

    public static void main(String[] args) {
//        RunnableImpl  run = new RunnableImpl();
        Thread t = new Thread(new RunnableImpl2());//4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        t.start();

        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

在Thread构造方法中传递哪个Runnable接口的实现类，就运行哪个线程。

匿名内部类实现多线程

匿名内部类的作用：简化代码
把子类继承父类、重写父类方法、创建子类对象合成一步完成
把实现类接口、重写接口中方法、创建实现类对象合成一步完成
匿名内部类的最终产物：子类/实现类对象，但是这个类没有名字
格式：

new 父类/接口(){
		重写父类/接口中的方法
};

public static void main(String[] args) {
        //线程的父类是Thread
        //new MyThread().start();
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"匿名内部类的重写线程方法");
                }
            }
        }.start();

        //线程的接口Runnable
        //Runnable r = new RunnableImpl();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"匿名内部类的重写线程方法");
                }
            }
        };
        new Thread(r).start();
    }

线程安全问题

我的理解就是多个线程在抢夺共享资源时出现的问题。
就比如电影院有三个售票窗口同时进行售票工作，当三个人分别前往每个窗口进行购票时，发生了同时抢夺一张票的行为，可以理解为线程不安全。
比如创建一个Runnable的实现类，run方法实现卖100张票；

public class RunnableImpl implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while(true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "线程正在卖第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

创建3个线程对象来抢夺同一个资源：
注意：这里是创建一个实现类对象，用3个线程对象去抢夺100张票。如果是创建3个实现类对象，那就是300张票了，就不存在抢夺共享资源的问题了。

public static void main(String[] args) {
        Runnable run = new RunnableImpl();
        Thread t0 = new Thread(run);
        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        t0.start();
        t1.start();
        t2.start();
    }

运行就会发现出现线程不安全的情况，三个线程抢夺共同的资源。

借用这张图就能很好理解为什么会出现同样的输出结果。

解决线程安全问题

1、同步代码块synchronized

格式：

synchronized(锁对象){
		可能出现线程安全的代码（访问的共享资源）
}

注意：

1. 通过代码块中的锁对象，可以使用任意的对象；
2. 必须保证多个线程使用的锁对象是同一个；
3. 锁对象作用：
   把同步代码块锁住，只让一个线程在同步代码块中执行。

public class RunnableImpl implements Runnable {
    private int ticket = 100;

    Object obj = new Object();
    @Override
    public void run() {
        while(true) {
            synchronized (obj){
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "线程正在卖第" + ticket + "张票");
                    ticket--;
                }
            }
        }
    }
}

加上锁就能保证，同步代码块中只能有一个线程在执行任务，只有当其线程执行完任务归还锁对象后，三个对象开始继续抢夺锁对象（cpu执行权）。同步保证了安全，但是程序频繁的判断锁、获取锁、释放锁，效率会降低。

2、同步方法

格式：

public synchronized void method(){
		可能会产生线程安全问题的代码
}

同步方法用的锁对象实际上就是实现类对象。（即本类对象）
同步方法也可以是静态的：
格式：

public static synchronized void method(){
		可能会产生线程安全问题的代码
}

但是静态的同步方法用的锁对象就不是实现类对象了，因为this是创建对象之后产生的，而静态方法优先于对象。静态方法的锁对象是本类的class属性，即class文件对象。等同于：

synchronized(RunnableImpl.class){
		线程安全问题代码块
}

3、Lock锁

Lock接口中的方法：void lock()获取锁、void unlock()释放锁
java.util.concurrent.locks.ReentrantLock implements Lock接口

使用方法：在成员位置创建一个ReentrantLock对象，并在可能出现安全问题的代码前调用lock方法获取锁，在之后调用unlock方法释放锁。

线程状态

API中可以查看线程的六种状态：

（写博客真的费时费力呜呜呜）

等待唤醒（包子铺举例）

顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态 （无限等待） 。
老板线程（生产者）：花一段时间做包子，做好之后调用notify方法，唤醒顾客吃包子。

public static void main(String[] args) {
        Object obj = new Object();

        new Thread(){
            @Override
            public void run() {
                synchronized (obj){
                    System.out.println("顾客1告知老板要的包子的种类和数量");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("被唤醒顾客1开始吃包子");
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                synchronized (obj){
                    System.out.println("开始做包子，需要花5秒");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("包子做好啦，去唤醒顾客咯~");
                    obj.notify();
                }
            }
        }.start();
    }

注意notify方法：唤醒在此 对象监视器（对象锁） 上等待的单个线程，会继续执行wait方法之后的代码。

obj.notify(); //如果有多个线程，随机唤醒一个
obj.notifyAll(); //唤醒所有等待的线程

进入TimeWaiting（计时等待）有两种方式：

1. 使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态；
2. 使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来。

线程池

java.util.concurrent.Executors:线程池的工厂类，用来生成线程池
Executors类中的静态方法：
static ExecutorService newFixedThreadPool(int nThreads)
创建一个可重用固定线程数的线程池
参数：
int nThreads:创建线程池中包含的线程数量
返回值：
ExecutorService接口，返回的是ExecutorService接口的实现类对象，可以使用ExecutorService接口接收（面向接口编程）

public static void main(String[] args) {
        //1、使用线程池的工厂类Executors里面提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
        ExecutorService es = Executors.newFixedThreadPool(2);
        //3、调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程，执行run方法
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
        //线程池会一直开启，使用完了线程，会把线程归还给线程池，线程可以继续使用
        es.submit(new RunnableImpl());
        es.submit(new RunnableImpl());
    }

public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程执行方法");
    }
}