1.线程安全

  线程安全的概念：当多个线程访问某一个类(对象或者方法)的时候，这个类始终都能表现出正确的行为，那么这个类(对象或者方法)及时线程安全的。
  synchronized：可以在任意对象及方法上加锁，而加锁的这段代码成为“互斥区”或者“临界区”。

  • 示例：
/**
 * @author bruceliu
 * @create 2019-02-25 21:02
 * 线程安全概念：当多个线程访问某一个类（对象或方法）时，这个对象始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。
 * synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为"互斥区"或"临界区"
 */
public class MyThreadDemo1 extends Thread {

    private int number = 20;

    @Override
    public void run() {
        number--;
        System.out.println("线程：" + Thread.currentThread().getName() + "-->number:" + number);
    }


    public static void main(String[] args) {
        /**
         * 分析：当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排对是按照CPU分配的先后顺序而定的），
         *      一个线程想要执行synchronized修饰的方法里的代码：
         *      1 尝试获得锁
         *      2 如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，
         *         而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）
         */
        MyThreadDemo1 myThread = new MyThreadDemo1();
        Thread t1 = new Thread(myThread, "t1");
        Thread t2 = new Thread(myThread, "t2");
        Thread t3 = new Thread(myThread, "t3");
        Thread t4 = new Thread(myThread, "t4");
        Thread t5 = new Thread(myThread, "t5");
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}

分析：当多个线程访问myThread的run方法时，以排队的方式进行处理（这里排对是按照CPU分配的先后顺序而定的）,一个线程想要执行synchronized修饰的方法里的代码：
1. 尝试获得锁
2. 如果拿到锁，执行synchronized代码体内容；拿不到锁，这个线程就会不断的尝试获得这把锁，直到拿到为止，而且是多个线程同时去竞争这把锁。（也就是会有锁竞争的问题）

2.多个线程多个锁

  多个线程多个锁：多个线程，每个线程都可以拿到自己指定的锁。分别获得锁之后，执行synchronized方法体中的内容。

  • 示例1：
/**
 * 关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁，
 * 所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock）.
 * @author bruceliu
 * @create 2019-02-25 21:15
 */
public class MyThreadDemo2 {

    private int number = 0;

    public synchronized void showNumber(String str) {
        try {
            if (str.equals("A")) {
                number = 100;
                Thread.sleep(4000);
                System.out.println("我是A,设置结束！");
            } else {
                number = 200;
                System.out.println("我是B,设置结束！");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        //俩个不同的对象
        final MyThreadDemo2 m1 = new MyThreadDemo2();
        final MyThreadDemo2 m2 = new MyThreadDemo2();

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                m1.showNumber("A");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                m2.showNumber("B");
            }
        });

        t1.start();
        t2.start();
    }
}

分析：关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）当做锁，所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock）.

  • 示例2：
/**
 * 在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）。
 * @author bruceliu
 * @create 2019-02-25 21:15
 */
public class MyThreadDemo2 {

    private static int number = 0;

    public static synchronized void showNumber(String str) {
        try {
            if (str.equals("A")) {
                number = 100;
                Thread.sleep(4000);
                System.out.println("我是A,设置结束！");
            } else {
                number = 200;
                System.out.println("我是B,设置结束！");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        //俩个不同的对象
        final MyThreadDemo2 m1 = new MyThreadDemo2();
        final MyThreadDemo2 m2 = new MyThreadDemo2();

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                m1.showNumber("A");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                m2.showNumber("B");
            }
        });

        t1.start();
        t2.start();
    }
}

分析：在静态方法上加synchronized关键字，表示锁定.class类，类一级别的锁（独占.class类）