Java中解决线程安全问题的两种方法Synchronized和加Lock锁

同步代码块：

使用对象：

synchronized(对象){
//需要被同步的代码；
}
//synchronized还可以放在方法声明中，表示整个方法为同步方法。例如：
public synchronized void show (String name){
….
 }

测试代码：

Lock(锁)

• 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
• ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

class A{
private final ReentrantLock lock = new ReenTrantLock();public void m(){
lock.lock();
try{
//保证线程安全的代码;
}
finally{
lock.unlock();
         }
      }
}
//注意：如果同步代码有异常，要将unlock()写入finally语句块

测试代码：

synchronized与Lock的对比

• Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
• Lock只有代码块锁，synchronized有代码块锁和方法锁
  使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

优先使用顺序：

Lock：同步代码块（已经进入了方法体，分配了相应资源）
同步方法：（在方法体之外）

在代码中实现：
public class ThreadTest {
/*创建多线程的方式：
1.继承Thread
2.实现Runnable
3.实现Callable
4.使用线程池

*/
public static class MyThread01 extends Thread {
    @Override
    public void run() {
        System.out.println("-----MyThread01");
    }
}

static class MyThread02 implements Runnable {
    public void run() {
        System.out.println("-----MyThread02");
    }
}

static class MyThread03 implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("-----MyThread03");
        return 200;
    }
}

public static class Test {
    public static void main(String[] args) {
        new MyThread01().start();
        new Thread(new MyThread02()).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread03());
        new Thread(futureTask).start();
        try {
            Integer value = futureTask.get();
            System.out.println(value);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

}