线程与锁的案例分析

线程安全

/*
 * 线程安全：当多个线程访问某一个类（方法、对象）时，这个类始终都能表现出正确的行为，那么其就是线程安全的。
 * synchronized：可以在任意对象及方法上加锁，而加锁的这段代码称为“互斥区”或“临界区”
 * 锁竞争
 */
package demo;

/**
 * 线程安全测试
 * @author 180285
 *  */
public class MyThread extends Thread{

    private int count = 5;

    //一个线程想要执行synchronized修饰的代码区，
    //1.尝试获得锁再执行；2.拿不到锁，就不断尝试获得直到得到为止。
    public synchronized void run(){
        count--;
        System.out.println(this.currentThread().getName()+"  count:"+count);
    }

    /**
     * 创建五个线程，线程不安全测试
     * @param args
     */
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        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");

        //线程执行的顺序，不是按代码书写的顺序，是按照CPU给线程分配的顺序。
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
结果：
没上锁：                        上锁
t2  count:2                     t1  count:4
t4  count:1                     t4  count:3
t5  count:0                     t5  count:2
t1  count:2                     t3  count:1
t3  count:2                     t2  count:0

多个线程多个对象、类级别的锁

package demo;

/*
 *  关键字synchronized取得的锁都是对象锁，而不是把一段代码（方法）锁起来；
 *  所以代码中哪个线程先执行synchronized关键字的方法，哪个线程就持有该方法所属对象的锁（Lock） new的新的对象就有新的锁；
 *  两个对象就有两个锁，互不影响
 *
 *  再静态方法上synchronized关键字，便是锁定class类，类层级的锁
 *
 */
public class MutiThread {

    private  static int num = 0;

    /*static 让这个方法的锁上升到类层面*/
    public static  synchronized void printNum(String tag){
        try {

            if (tag.equals("a")) {
                num = 100;
                System.out.println("tag a ,set num over");
                Thread.sleep(1000);
            } else {
                num = 200;
                System.out.println("tag b, set num over");
            }

            System.out.println("tag"+tag+", num: "+num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    //test
    public static void main(String[] args) {

        final MutiThread m1 = new MutiThread();
        final MutiThread m2 = new MutiThread();

        //线程1
        Thread  t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                m1.printNum("a");
            }
        });

        //线程2
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                m2.printNum("b");
            }
        });

        //线程t1，t2开始
        t1.start(); 
        t2.start();
        //未加static——预期的结果是tag a, set num over, tag a ,num : 100;然后在执行t2，事实不是这样的
    }
}
结果：
static synchronized时的结果。

tag a ,set num over
taga, num: 100
tag b, set num over
tagb, num: 200

只有synchronized时的结果。

tag a ,set num over
tag b, set num over
tagb, num: 200
taga, num: 100

同步锁、异步锁

• 方法，对象默认都是异步的asynchronized

package demo;

public class MyObject {

    public synchronized void method1(){
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /*默认是异步的，加锁会同步*/
    public synchronized void method2(){
        System.out.println(Thread.currentThread().getName());
    }

    //test
    public static void main(String[] args) {

        final MyObject my1 = new MyObject();

        //线程1
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                my1.method1();
            }
        },"t1");

        //线程2
        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                my1.method2();
            }
        },"t2");

        //开始t1，t2线程
        t1.start();
        t2.start();
        /*
         * 总结：
         * 多个线程、一个对象，t1，t2可以以异步的方式调用对象的非synchronized修饰的方法
         *              上锁的方法必须等待，一个对象只有一个锁。
         * */
    }
}

• 上诉结果中，只是打印两个线程的名字，在method2方法没有锁时，t1，t2是同时打印的。上锁之后是先打印t1，4秒之后打印t2。