二十五、JAVA多线程（三、线程同步）

线程不安全的问题分析

当多线程并发访问同一个资源对象的时候,可能出现线程不安全的问题.但是,我们分析打印的结果,发现没有问题，意识:看不到问题,我们经验不够,问题出现的不够明显.接下来为了让问题更明显:我们使用Thread.sleep(10);//当前线程睡10毫秒,当前线程休息着,让其他线程去抢资源. 经常用来模拟网络延迟。

*：在程序中并不是使用Thread.sleep(10)之后,程序才出现问题,而是使用之后,问题更明显。

代码演示：

package synchronizeddemo;class Apple implements Runnable{private int num = 50;@Overridepublic void run() {for (int i = 0; i < 50; i++) {if(num > 0){try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"吃了编号为"+num+"的苹果");num--;}}}}public class SynchronizedBlock {public static void main(String[] args) {Apple apple = new Apple();new Thread(apple,"dodo").start();new Thread(apple,"haha").start();new Thread(apple,"lili").start();}
}

代码运行结果：

代码讲解：①：:在线程的run方法上不能使用throws来声明抛出异常,只能在方法中使用try-catch来处理异常，原因是:子类覆盖父类方法的原则,子类不能抛出新的异常，在Runnable接口中的run方法,都没有声明抛出异常。②：为什么50的苹果被吃三次，还出现-1的苹果？原因是，当其中一个线程进入拿到苹果，还没执行num--,其他线程也进来拿苹果导致，出现了多次重复的苹果现象，还有出现-1的问题，所以我们需要引入原子性的概念。

要解决上述多线程并发访问多一个资源的安全性问题:
解决方案:保证打印苹果编号和苹果总数减1操作,必须同步完成.
A线程进入操作的时候,B和C线程只能在外等着,A操作结束,A和B和C才有机会进入代码去执行.
-------------------------------------------------------------------------------------------
方式1:同步代码块
方式2:同步方法
方式3:锁机制(Lock)

方式1：同步代码块

同步代码块:
语法:
synchronized(同步锁)
{
需要同步操作的代码
}
--------------------------------------------------------------------------------------------
同步锁:
为了保证每个线程都能正常执行原子操作,Java引入了线程同步机制。同步监听对象/同步锁/同步监听器/互斥锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁，Java程序运行使用任何对象作为同步监听对象,但是一般的,我们把当前并发访问的共同资源作为同步监听对象。
注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着。

代码演示：

package synchronizeddemo;class Apple implements Runnable{private int num = 50;@Overridepublic void run() {for (int i = 0; i < 50; i++) {synchronized (this) {if(num > 0){try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"吃了编号为"+num+"的苹果");num--;}}  }   }
}public class SynchronizedBlock {public static void main(String[] args) {Apple apple = new Apple();new Thread(apple,"dodo").start();new Thread(apple,"haha").start();new Thread(apple,"lili").start();}
}

代码讲解：加入同步锁以后，运行代码，我们将能保证线程同步了，同步代码块的使用，一定要记住将需要同步完成的动作包含进同步代码块里，这是逻辑上需要考虑的事，这里我们的同步锁对象用的是this即apple对象，没有使用num的原因是，因为num这个数字一直在变，用来当同步锁对象是不合理的。

方式2：同步方法

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

synchronized public    void doWork(){
         ///TODO
    }
同步锁是谁:
      对于非static方法,同步锁就是this.
      对于static方法,我们使用当前方法所在类的字节码对象(Apple2.class).

代码演示：

package synchronizeddemo;class Apple2 implements Runnable{private int num = 50;@Overridepublic void run() {for (int i = 0; i < 50; i++) {eat();} }   //此时方法的同步锁对象就是this,指代当前的apple对象synchronized private void eat(){if(num > 0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"吃了编号为"+num+"的苹果");num--;}}
}public class SynchronizedMethod {public static void main(String[] args) {Apple2 apple = new Apple2();new Thread(apple,"dodo").start();new Thread(apple,"haha").start();new Thread(apple,"lili").start();}
}

代码讲解：不要使用synchronized修饰run方法,修饰之后,某一个线程就执行完了所有的功能，好比是多个线程出现串行。解决方案:把需要同步操作的代码定义在一个新的方法中,并且该方法使用synchronized修饰,再在run方法中调用该新的方法即可。

synchronized的优缺点

优点:保证了多线程并发访问时的同步操作,避免线程的安全性问题.
缺点:使用synchronized的方法/代码块的性能比不用要低一些.
建议:尽量减小synchronized的作用域。
-------------------------------------------------------------------------------
使用synchronized 安全保证了,但是性能降低了。
不使用synchronized 此时性能高了,但是安全问题出现了。
-------------------------------------------------------------------------------
面试题:
1:StringBuilder和StringBuffer的区别.
2:说说ArrayList和Vector的区别,HashMap和Hashtable的区别.

方法三：同步锁

同步锁（Lock）:Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

API:

代码演示：

package synchronizeddemo;import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;class Apple3 implements Runnable {private int num = 500;// 创建锁对象Lock lock = new ReentrantLock();@Overridepublic void run() {for (int i = 0; i < 500; i++) {eat();}}private void eat() {// 一进方法就获取锁lock.lock();try {if (num > 0) {Thread.sleep(100);System.out.println(Thread.currentThread().getName() + "吃了编号为" + num + "的苹果");num--;}} catch (Exception e) {// TODO: handle exception} finally {// 释放锁lock.unlock();}}
}public class LockDemo {public static void main(String[] args) {Apple3 apple = new Apple3();new Thread(apple, "dodo").start();new Thread(apple, "haha").start();new Thread(apple, "lili").start();}
}

单例模式设计

我们先来写个懒汉式（懒加载）提出问题

代码演示：

package singletonpattern;//单例模式-懒汉式
public class ArrayUtil1 {//构造器私有化，防止外界创建对象private ArrayUtil1(){}private static ArrayUtil1 instance = null;//存在线程安全问题public static ArrayUtil1 getInstance(){if(instance==null){instance = new ArrayUtil1();}return instance;}}

代码讲解：上述代码存在线程安全问题，因此我们加入synchronized,修改成下述代码

package singletonpattern;//单例模式-懒汉式
public class ArrayUtil1 {//构造器私有化，防止外界创建对象private ArrayUtil1(){}private static ArrayUtil1 instance = null;//存在线程安全问题synchronized public static ArrayUtil1 getInstance(){if(instance==null){instance = new ArrayUtil1();}return instance;}}

代码讲解：我们知道synchronized加入后，线程安全了--->性能下降了，所以我们应该尽量减小synchronized的作用范围，再次修改成下述代码:

package singletonpattern;//单例模式-懒汉式
public class ArrayUtil1 {//构造器私有化，防止外界创建对象private ArrayUtil1(){}private static ArrayUtil1 instance = null;//同步方法，此时监听对象应该指向ArrayUtil1.classpublic static ArrayUtil1 getInstance(){synchronized (ArrayUtil1.class) {if(instance==null){instance = new ArrayUtil1();}}return instance;}
}

我们能够看到，单例模式-懒汉式，尽管我们加入synchronized，但是还是降低了性能，所以我们单例设计，一般推荐饿汉式，暴力，简单

代码演示：

package singletonpattern;//单例模式-饿汉式
public class ArrayUtil2 {//构造器私有化，防止外界创建对象private ArrayUtil2(){}private static ArrayUtil2 instance = new ArrayUtil2();//同步方法，此时监听对象应该指向ArrayUtil1.classpublic static ArrayUtil2 getInstance(){return instance;}
}