java线程同步 synchronized失效？？？（理解好是否上锁的是同一个对象，因为同一个对象对应的run( ) 是同一个）

java线程同步 synchronized失效？？？（理解好是否上锁的是同一个对象）

看是否给同一个对象上锁！

情况是1：多个线程执行同个对象,即多个运行任务的线程执行同一个任务对象

情况2：多个线程执行不同的多个对象，即多个运行任务的线程执行不同的多个任务对象

（~~~~~~~~~~~~~~~~~~第一个例子如果看不太清晰的话，请看第二个例子（是第一个例子简洁版啦，帮你理一下）~~~~~~~~~~~~~~~~~~~~~~~~~~~）

第一个例子~~~

情况一：（包括加synchronized 和没加 synchronized 的情况：）

情况二：（包括加synchronized 和没加 synchronized 的情况：）

代码：

❀ts 测试类

package eating;

public class ts {
      public static void main(String[] args){
          AppleNum appleNum = new AppleNum(20);
//          Apple apple = new Apple(appleNum);
          Apple[] apple = new Apple[5];
          String[] names = { "小红", "小黄", "小蓝", "小绿", "小青" };
          for(int i = 0; i < names.length; i++) {
              apple[i] = new Apple(appleNum);
              new Thread(apple[i], names[i]).start();
          }

      }
}

❀AppleNum 苹果数量类：

package eating;

public class AppleNum {
    /* 苹果数量 */
    int num;
    public AppleNum(int num) {
        this.num = num;
    }
    public int getNum() {
        return num;
    }
    public int setNum(int num2) {
        return num -= num2;
    }
}

❀Apple 苹果类：

package eating;

import java.util.concurrent.TimeUnit;

class Apple implements Runnable {

    private AppleNum appleNum;
    public Apple(AppleNum appleNum) {
        this.appleNum = appleNum;
    }
    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                if (appleNum.getNum() > 0) {
                    System.out.println(Thread.currentThread().getName() + "拿了第" + appleNum.setNum(1) + "个苹果");
                    try {
                        TimeUnit.MILLISECONDS.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
}

不好意思是不是把你绕晕了。。。。。。先看一下第二个例子先，然后咱再分析第一例子的情况

第二个例子~~

~~~~~~~~~第二个例子（理一下多线程竞争的情况~~~同一个对象、不同个对象！！！）

❀TeacherApple 类：

package SendApple;

public class TeacherApple implements Runnable{
    private int apples = 5;

    public void run() {
        while (true) {
            if (apples > 0) {
                Thread th = Thread.currentThread();
                String th_name = th.getName();
                System.out.println(th_name + "正在发第" + apples-- + "个苹果");
            }
        }
   }
}

✿ 情况一：不同执行任务的线程执行的是同一个对象：

package SendApple;

public class Apple {
    public static void main(String[] args) {
        String names[] = {"李老师", "张老师", "徐老师"};
        TeacherApple theacherApple = new TeacherApple();　　　//theacherApple 是后边执行的同一个对象
        for(int i = 0; i < names.length; i++) {
            new Thread(theacherApple, names[i]).start();     //不同执行任务的线程执行的是同一个对象：theacherApple
        }
    }
}

✿ 情况二：不同执行任务的线程执行的是不同的多个对象：

package SendApple;

public class Apple {
    public static void main(String[] args) {
        String names[] = {"李老师", "张老师", "徐老师"};
        TeacherApple[] theacherApple = new TeacherApple[3];　　　　//是后边执行的不同的多个对象
        for(int i = 0; i < names.length; i++) {
            theacherApple[i] = new TeacherApple();
            new Thread(theacherApple[i], names[i]).start();　　　　//不同执行任务的线程执行的是不同的多个对象：
        }
    }
}

总结一下：

多线程特点：不断的竞争抢资源。

同一个对象用不同线程执行：相当于不同线程里去竞争同一个对象里边的资源。

不同对象用不同的线程去执行：相当于线程A执行A对象的资源，线程B执行线程B对象的资源，线程的关系永远是竞争关系。

例子二分析：

对象内部run() 方法要求打印的那个语句被执行5次。

例子二：第一种情况：只有一个对象，则只有一个run() 方法。3个 线程们竞争的姿态来到同一对象的run() 方法里的同一个语句时，抢该对象run() 方法的该语句的执行，直到该对象被不同线程执行的次数之和是5次结束。

例子二：第二种情况：有个5个对象，则有5个run()方法。new Thread(theacherApple[i], names[i]).start(); 则一个线程负责一个对象的run() 方法。每个线程都有对应的负责对象的run() 方法，然后run() 方法里的打印语句5次的执行。

例子一分析：

关于线程同步问题在于面对同一份资源时，出现了数据错误情况（非线程安全）

同一个资源：（共享资源）··························ApppleNum对象 ，在main 方法里它是只建立一次的，所以它在内存中位置不变，然后在apple的构造方法里被作为参数传入。

这里要注意不管是建立了多个Apple 对象还是一个 Apple 对象时，咱 ApppleNum对象 （共享资源）的数量都是一，是它是它，就是它！

情况一的分析：

只有一个对象时，只有一个run() 方法。

同一对象（Apple）里边有同一个对象属性（ApppleNum），run() 方法是：要求苹果数( appleNum.getNum() > 0 )，没加 synchronized 时，多个线程启动了同一个Apple的同一个run() 方法时，因为咱的唯一 ApppleNum对象 的数量被不同线程看到那一刻数量可能都是（例如 20），然后如果不加关键字，则咱不同线程要纷纷对咱的唯一 ApppleNum对象的数量进行减少并打印，不加锁的话，则线程们都看到时可能看到的数据是同一个（例如都是20），导致线程A（在20的基础上）减少1后，线程B也是（在20的基础上）减少1，导致数据出错啦!

加锁：线程A进去门被琐住了，其他线程在外面等待，线程A看到（假设ApppleNum对象的数量是20），减少1 后，解锁，然后线程B 再进去，再锁上，然后看到，然后减1。。。。。。

情况二的分析：

五个对象时，有五个不同的run() 方法呀。

不同对象（Apple[ i ] ）的run() 方法使用不同线程启动，假设线程A 启动的是 Apple【0】对象的run() 方法，然后对咱的唯一 ApppleNum对象的数量进行减少1并打印，加不加锁头时，影响不到问题实质。例如不加锁头，五个run()方法对应的5个线程执行对共享资源（咱的唯一 ApppleNum对象的数量），进行减1并打印，5个run()方法对应的线程同时竞争到这里。例如加锁头，五个run() 方法对应的线程竞争到那里都是锁一下的动作，然后还是执行对共享资源（咱的唯一 ApppleNum对象的数量），进行减1并打印。

总结：打个比方：

一个对象，一个run() 方法，相当于同一个厕所的门，五个线程来到同一个厕所的门，如果（厕所）没有锁上，五个线程都想上厕所，一个线程进去了其他线程还能进去，就会出现线程们都挤到厕所里，如果（厕所）有锁上，一个线程进去了其他线程进不去，在外面等待。然后。。。。（穷人厕所，多人上）

五个对象，五个run() 方法，相当于五个厕所的门，五个线程站在自己对应的厕所门那里，如果门开了，各自进各自的厕所，（这时候啊，那一扇厕所门，外面就他一个人，没有其他人！！！即私人专享vip 厕所），门没有锁，他进去该干嘛就干嘛，门有锁了，他进去该干嘛还是干嘛。。。。。（vip 厕所，私人专上）

同一份资源（共享资源）：相当厕所的冲厕所的那一桶水，谁上完厕所，厕所都要冲水，不管是哪个厕所（穷人厕所，多人上还是 vip 厕所，私人专上），上完厕所，就要冲水。

ps:线程安全？非线程安全？什么是线程同步？

线程安全？线程不安全？

线程不安全：在不提供加锁机制保护时，出现了多个线程先后更新数据所得的数据是脏数据。举例子：买票时，如果不排队，抢着买票，A看到票数是100（B也马上看到了，在A买之前，B看到的票数也是100），A买了，则站在A的角度，这时候票数更新为99，然后B也来买，则站在B的角度，票数应该为99（因为B看到的票数是100）. 明明被买了两张票，结果票数却是99.

什么是线程同步？~~ synchronized 关键字、线程加锁

线程同步：当线程们访问同一个共享资源时，需要通过线程同步机制，当第一个线程进去时，就把共享资源进行加锁，然后同步资源的状态给后边进去的线程。 线程同步的是把前一个线程更新后的状态传递给下一位线程。

✿ 线程同步其实实现的是线程排队。防止线程同步访问共享资源造成冲突。变量需要同步，常量不需要（常量存放于方法区）。

参考：

https://www.cnblogs.com/xrq730/p/6662232.html