1.为什么要使用synchronized


在并发编程中存在线程安全问题，主要原因有：1.存在共享数据 2.多线程共同操作共享数据。关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。
2.实现原理


synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性
3.synchronized的三种应用方式


Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

4.synchronized的作用

Synchronized是Java中解决并发问题的一种最常用最简单的方法 ，他可以确保线程互斥的访问同步代码
5.举栗子

**一、synchronized作用于实例方法**
①多个线程访问同一个对象的同一个方法
public class synchronizedTest implements Runnable {
    //共享资源
    static int i =0;
    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase(){
        i++;
    }
    @Override
    public void run(){
        for (int j =0 ; j<10000;j++){
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        synchronizedTest test = new synchronizedTest();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}


结果：



分析：当两个线程同时对一个对象的一个方法进行操作，只有一个线程能够抢到锁。因为一个对象只有一把锁，一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，就不能访问该对象的其他synchronized实例方法，需要等到对象被释放后才能获取，但是在对象没有被释放前，其他线程可以访问非synchronized修饰的方法
②一个线程获取了该对象的锁之后，其他线程来访问其他synchronized实例方法现象  举栗
public class SynchronizedTest {
    public synchronized void method1() {
        System.out.println("Method 1 start");
        try {
            System.out.println("Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public synchronized void method2() {
        System.out.println("Method 2 start");
        try {
            System.out.println("Method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }


    public static void main(String[] args) {
        final SynchronizedTest test = new SynchronizedTest();

        new Thread(test::method1).start();

        new Thread(test::method2).start();
    }

}


结果：



分析：可以看出其他线程来访问synchronized修饰的其他方法时需要等待线程1先把锁释放
③一个线程获取了该对象的锁之后，其他线程来访问其他非synchronized实例方法现象  举栗

去掉②中方法二的synchronized
public class SynchronizedTest {
    public synchronized void method1() {
        System.out.println("Method 1 start");
        try {
            System.out.println("Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public void method2() {
        System.out.println("Method 2 start");
        try {
            System.out.println("Method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }


    public static void main(String[] args) {
        final SynchronizedTest test = new SynchronizedTest();

        new Thread(test::method1).start();
        new Thread(test::method2).start();
    }

}


结果：



分析：当线程1还在执行时，线程2也执行了，所以当其他线程来访问非synchronized修饰的方法时是可以访问的
④当多个线程作用于不同的对象
public class SynchronizedTest {
    public synchronized void method1() {
        System.out.println("Method 1 start");
        try {
            System.out.println("Method 1 execute");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 1 end");
    }

    public synchronized void method2() {
        System.out.println("Method 2 start");
        try {
            System.out.println("Method 2 execute");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method 2 end");
    }


    public static void main(String[] args) {
        final SynchronizedTest test1 = new SynchronizedTest();
        final SynchronizedTest test2 = new SynchronizedTest();

        new Thread(test1::method1).start();

        new Thread(test2::method2).start();
    }

}


结果：



分析：因为两个线程作用于不同的对象，获得的是不同的锁，所以互相并不影响
**此处思考一个问题：为什么分布式环境下synchronized失效？如何解决这种情况？**
**二、synchronized作用于静态方法**
public class synchronizedTest implements Runnable {
    //共享资源
    static int i =0;
    /**
     * synchronized 修饰实例方法
     */
    public static synchronized void increase(){
        i++;
    }
    @Override
    public void run(){
        for (int j =0 ; j<10000;j++){
            increase();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new synchronizedTest());
        Thread t2 = new Thread(new synchronizedTest());
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }

结果：



分析：由例子可知，两个线程实例化两个不同的对象，但是访问的方法是静态的，两个线程发生了互斥（即一个线程访问，另一个线程只能等着），因为静态方法是依附于类而不是对象的，当synchronized修饰静态方法时，锁是class对象。
**三、synchronized作用于同步代码块**
为什么要同步代码块呢？在某些情况下，我们编写的方法体可能比较大，同时存在一些比较耗时的操作，而需要同步的代码又只有一小部分，如果直接对整个方法进行同步操作，可能会得不偿失，此时我们可以使用同步代码块的方式对需要同步的代码进行包裹，这样就无需对整个方法进行同步操作了。
 public class synchronizedTest implements Runnable {
    static synchronizedTest instance=new synchronizedTest();
    static int i=0;
    @Override
    public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized(instance){
            for(int j=0;j<10000;j++){
                i++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(i);
    }
}

结果：



分析：将synchronized作用于一个给定的实例对象instance，即当前实例对象就是锁对象，每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁，如果当前有其他线程正持有该对象锁，那么新到的线程就必须等待，这样也就保证了每次只有一个线程执行i++;操作。当然除了instance作为对象外，我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁，如下代码：
//this,当前实例对象锁
synchronized(this){
    for(int j=0;j<1000000;j++){
        i++;
    }
}

//class对象锁
synchronized(AccountingSync.class){
    for(int j=0;j<1000000;j++){
        i++;
    }
}

   为了方便各位网友学习以及方便自己复习之用，将Java并发编程系列内容系列内容按照由浅入深的学习顺序总结如下，点击相应的标题即可跳转到对应的文章

 

   【Java并发编程】实现多线程的两种方法

   【Java并发编程】线程的中断

   【Java并发编程】正确挂起、恢复、终止线程

   【Java并发编程】守护线程和线程阻塞

   【Java并发编程】Volatile关键字（上）

   【Java并发编程】Volatile关键字（下）

   【Java并发编程】synchronized关键字

   【Java并发编程】synchronized的另个一重要作用：内存可见性

   【Java并发编程】实现内存可见性的两种方法比较：synchronized和Volatile

   【Java并发编程】多线程环境下安全使用集合API

   【Java并发编程】死锁

   【Java并发编程】可重入内置锁

   【Java并发编程】线程间协作：wait、notify、notifyAll

   【Java并发编程】notify通知的遗漏

   【Java并发编程】notifyAll造成的早期通知问题

   【Java并发编程】生产者—消费者模型

   【Java并发编程】深入Java内存模型（1）——happen—before规则及其对DCL问题的分析

   【Java并发编程】深入Java内存模型（2）——内存操作规则总结

   【Java并发编程】并发新特性—Executor框架与线程池

   【Java并发编程】并发新特性—Lock锁与条件变量

   【Java并发编程】并发新特性—阻塞队列与阻塞栈

   【Java并发编程】并发新特性—障碍器CyclicBarrier

   【Java并发编程】并发新特性—信号量Semaphore


   为了方便各位网友学习以及方便自己复习之用，将Java并发编程系列内容系列内容按照由浅入深的学习顺序总结如下，点击相应的标题即可跳转到对应的文章

 

   【Java并发编程】实现多线程的两种方法

   【Java并发编程】线程的中断

   【Java并发编程】正确挂起、恢复、终止线程

   【Java并发编程】守护线程和线程阻塞

   【Java并发编程】Volatile关键字（上）

   【Java并发编程】Volatile关键字（下）

   【Java并发编程】synchronized关键字

   【Java并发编程】synchronized的另个一重要作用：内存可见性

   【Java并发编程】实现内存可见性的两种方法比较：synchronized和Volatile

   【Java并发编程】多线程环境下安全使用集合API

   【Java并发编程】死锁

   【Java并发编程】可重入内置锁

   【Java并发编程】线程间协作：wait、notify、notifyAll

   【Java并发编程】notify通知的遗漏

   【Java并发编程】notifyAll造成的早期通知问题

   【Java并发编程】生产者—消费者模型

   【Java并发编程】深入Java内存模型（1）——happen—before规则及其对DCL问题的分析

   【Java并发编程】深入Java内存模型（2）——内存操作规则总结

   【Java并发编程】并发新特性—Executor框架与线程池

   【Java并发编程】并发新特性—Lock锁与条件变量

   【Java并发编程】并发新特性—阻塞队列与阻塞栈

   【Java并发编程】并发新特性—障碍器CyclicBarrier

   【Java并发编程】并发新特性—信号量Semaphore

Java并发编程（1）：可重入内置锁
Java并发编程（2）：线程中断（含代码）
Java并发编程（3）：线程挂起、恢复与终止的正确方法（含代码）
Java并发编程（4）：守护线程与线程阻塞的四种情况
Java并发编程（5）：volatile变量修饰符—意料之外的问题（含代码）
Java并发编程（6）：Runnable和Thread实现多线程的区别（含代码）
Java并发编程（7）：使用synchronized获取互斥锁的几点说明
Java并发编程（8）：多线程环境中安全使用集合API（含代码）
Java并发编程（9）：死锁（含代码）
Java并发编程（10）：使用wait/notify/notifyAll实现线程间通信的几点重要说明
Java并发编程（11）：线程间通信中notify通知的遗漏（含代码）
Java并发编程（12）：线程间通信中notifyAll造成的早期通知问题（含代码）
Java并发编程（13）：生产者—消费者模型（含代码）
Java并发编程（14）：图文讲述同步的另一个重要功能—内存可见性
Java并发编程（15）：并发编程中实现内存可见的两种方法比较—加锁和volatile变量
Java并发编程（16）：深入Java内存模型—happen-before规则及其对DCL的分析（含代码）
Java并发编程（17）：深入Java内存模型—内存操作规则总结
Java并发编程（18）：第五篇中volatile意外问题的正确分析解答（含代码）
Java并发编程（19）：并发新特性—Executor框架与线程池（含代码）
Java并发编程（20）：并发新特性—Lock锁和条件变量（含代码）

1 推荐资源 

blog: 并发编程网-http://ifeve.com/java_multi_thread_programming_1_2/ 

书籍：JAVA并发编程实践 http://vdisk.weibo.com/s/aP04X7rRcCoks 

2 提纲 

        并发程序能够提高多核处理器利用率，加快响应。即便是单核的情况下，并发程序也能有效的提高性能。和并发编程对应的是顺序编程，顺序编程中程序只能按照顺序执行。当程序因等待资源阻塞时，整个程序也被迫等待。并发编程能够在一个任务阻塞的情况下切换到另一个任务，有效的提高程序的性能。 

有许多方法来实现并发编程，如多进程、函数式编程、多线程。进程自己拥有单独的内存空间，能够独立运行而不受其他进程的影响，因此有人把多进程看做并发编程唯一途径。函数式编程是一种没有副作用的编程范式。因为 FP 语言不包含任何赋值语句，变量值一旦被指派就永远不会改变。而且，调用函数只会计算出结果 ── 不会出现其他效果。因此，FP 语言没有副作用。Java是采用多线程的方法实现并发编程，线程被认为是“轻量级的进程“。线程之间共享内存，线程的创建、消失和上下文切换都是轻量级的。但是，使用多线程的引入会带来线程安全、活跃度危险和性能危险。如果是安全意味着”什么坏事都没有发生过”，活跃度失效是与之互补的一面“好事最终发生了”而性能意味着“好事很快尽快发生”【JAVA并发编程实践】。 

JAVA多线程提纲 


Callable接口和Runnable接口区别：

区别:1Callable使用call（）方法，Runnable使用run()方法 

2.call方法的原型为public interface Callable 

{ 

    V call() throws Exception; 

} run方法的原型: 

public interface Runnable 

{ 

    void call(); 

}  

可分成两点： 

a.call方法有返回值，run方法没有返回值 

b.call方法可以抛出被处理的异常,run方法不能抛出异常 

3.Runnable接口是java1.1引入的，Callable是java1.5新引入的。