1. 线程安全性

1.1. 继承方式VS实现方式（掌握）

当多线程并发访问同一个资源时，会导致线程出现安全性的原因，看案例。

案例：现有50个苹果，现在有请三个童鞋(小A、小B、小C)上台表演吃苹果。

因为A、B、C三个人可以同时吃苹果，此时得使用多线程技术来实现这个案例。

分析: 可以定义三个线程对象，并启动线程.

第一步：每一个同学吃苹果的时候：先展示自己拿到手上苹果的编号，如1，2，3，36...

第二步：再吃掉苹果（意味着苹果的总数少一个）

方式1:可以使用继承Thread方式来实现.

方式2:可以使用实现Runnable方式来实现.

使用继承方式

class Person extends Thread {

    private int num = 50;//苹果总数

    public Person(String name) {

        super(name);

    }

    public void run() {

        for (int i = 0; i < 50; i++) {

            if (num > 0) {

                System.out.println(super.getName() + "吃了编号为：" + num-- + "的苹果");

            }

        }

    }

}

public class ThreadDemo1 {

    public static void main(String[] args) {

        //创建三个线程，吃苹果

        new Person("小A").start();

        new Person("小B").start();

        new Person("小C").start();

    }

}

使用继承方式完成该案例的时候，会发现A、B、C都各自吃了50个苹果，为何？

使用实现方式

class Apple implements Runnable {

    private int num = 50;//苹果总数

    public void run() {

        for (int i = 0; i < 50; i++) {

            if (num > 0) {

                System.out.println(Thread.currentThread().getName()

+ "吃了编号为：" + num-- + "的苹果");

            }

        }

    }

}

public class ThreadDemo2 {

    public static void main(String[] args) {

        Apple a = new Apple();

        //创建三个线程，吃苹果

        new Thread(a, "小A").start();

        new Thread(a, "小B").start();

        new Thread(a, "小C").start();

    }

}

在使用实现方式的时候，我们发现A、B、C一共吃了50个苹果，为何？

通过吃苹果比赛，分析继承方式和实现方式的区别：

继承方式：

• Java中类是单继承的，如果继承了Thread了，该类就不能再有其他的直接父类了。

• 从操作上分析，继承方式更简单，获取线程名字也简单。

• 从多线程共享同一个资源上分析，继承方式不能多个线程共享同一个资源。

实现方式：

• Java中类可以多实现接口，此时该类还可以继承其他类，并且还可以实现其他接口（设计上,更优雅）。

• 从操作上分析，获取线程名字也比较复杂，得使用Thread.currentThread()来获取当前线程的引用。

• 从多线程共享同一个资源上分析，实现方式可以多线程共享同一个资源。

1.2. 线程同步（掌握）

当多线程并发访问同一个资源对象的时候,可能出现线程不安全的问题。

但是，分析打印的结果，有时候发现没有问题：

意识：看不到问题，不代表没有问题，可能是我们经验不够，或者说问题出现的不够明显。

那么可以使用线程休眠来模拟网络延迟，让问题来得更明显一些：

Thread.sleep(10);//当前线程睡10毫秒,当前线程休息着,让其他线程去抢资源.           

在程序中并不是使用Thread.sleep(10)之后程序才出现问题，而是使用之后，问题更明显，休眠的时间越久问题越明显，一般用10或100即可，具体根据情况而定。

class Apple implements Runnable {

    private int num = 50;//苹果总数

    public void run() {

        try {

            for (int i = 0; i < 50; i++) {

                if (num > 0) {

                    Thread.sleep(10);

                    System.out.println(Thread.currentThread().getName()

 + "吃了编号为：" + num-- + "的苹果");

                }

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

分析运行结果，为什么有错误的结果。

在这里，打印苹果的编号和苹果数量的减少，应该是一个原子操作，也就说是一个不能分割的操作，两个步骤之间不能被其他线程插一脚。

第一步：System.out.println(Thread.currentThread().getName()

• "吃了编号为：" + num + "的苹果");

第二步：num --;

解决方案：保证打印苹果编号和苹果总数减1操作，必须同步完成。

解决思路：A线程获得同步锁进入操作的时候，B和C线程只能在外等着，A操作结束，释放同步锁。A和B和C才有机会去抢同步锁（谁获得同步锁，谁才能执行代码）。

通俗例子：A、B、C三个人去抢厕所的雅间，为了保证安全规定谁抢到了必须上锁，把其他人排除外雅间外面。若A抢到了，进入后应该立马上锁，B和C只能在外等着，当A释放锁出来的时候，A、B、C又开始尝试抢资源。

• 方式1：同步代码块

• 方式2：同步方法

1.2.1. 同步代码块（掌握）

同步代码块语法:

synchronized(同步锁){

     需要同步操作的代码

}

同步锁，又称之为同步监听对象/同步锁/同步监听器/互斥锁：

为了保证每个线程都能正常执行原子操作，Java引入了线程同步机制。

对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁。

Java程序允许使用任何对象作为同步监听对象，一般的，我们把当前并发访问的共同资源作为同步监听对象，比如此时三个线程的共同资源Apple对象。

注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就执行，其他的线程只能在代码块外等着。

class Apple implements Runnable {

    private int num = 50;//苹果总数

    public void run() {

        try {

            for (int i = 0; i < 50; i++) {

                synchronized (this) {

                    if (num > 0) {

                        Thread.sleep(10);

                        System.out.println(Thread.currentThread().getName()

+ "吃了编号为：" + num-- + "的苹果");

                    }

                }

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

此时的同步锁this表示Apple对象，而程序中Apple对象只有一份，故可以作为同步锁。

1.2.2. 同步方法（掌握）

使用synchronized修饰的方法，就叫做同步方法。保证A线程执行该方法的时候，其他线程只能在方法外等着。

synchronized  public  void  doWork(){

     ///TODO

}

此时同步锁是谁——其实就是，调用当前同步方法的对象：

• 对于非static方法，同步锁就是this。

• 对于static方法，同步锁就是当前方法所在类的字节码对象。

class Apple implements Runnable {

    private int num = 50;//苹果总数

    public void run() {

        for (int i = 0; i < 50; i++) {

            this.eat();

        }

    }

    synchronized private void eat() {

        try {

            if (num > 0) {

                Thread.sleep(10);

                System.out.println(Thread.currentThread().getName()

+ "吃了编号为：" + num-- + "的苹果");

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

1.2.3. synchronized的优劣（掌握）

好处：保证了多线程并发访问时的同步操作，避免线程的安全性问题。

缺点：使用synchronized的方法/代码块的性能要低一些。

建议：尽量减小synchronized的作用域。

面试题:

1、StringBuilder和StringBuffer的区别

2、说说ArrayList和Vector的区别

3、HashMap和Hashtable的区别

通过源代码会发现，主要就是方法有没有使用synchronized的区别，比如StringBuilder和StringBuffer。

image.png

因此得出结论：使用synchronized修饰的方法性能较高，但是安全性较低，反之则反。

若要获得最好的学习效果，需要配合对应教学视频一起学习。需要完整教学视频，请参看https://ke.qq.com/course/272077。