线程（一）

一、线程安全锁-synchronized

1、什么是线程安全：当多个线程访问一个类对象或方法时，该对象或方法都能表现正确行为，就是线程安全

2、synchronized:可以用在代码块或方法上

public class SynchronizedTest extends Thread {

    private int count = 5;

    @Override
    public void run() {
        count --;
        System.out.println(Thread.currentThread().getName() + "---count:" + count);
    }

    public static void main(String[] args) {
        SynchronizedTest synchronizedTest = new SynchronizedTest();
        Thread thread = new Thread(synchronizedTest, "t1");
        Thread thread2 = new Thread(synchronizedTest, "t2");
        Thread thread3 = new Thread(synchronizedTest, "t3");
        Thread thread4 = new Thread(synchronizedTest, "t4");
        Thread thread5 = new Thread(synchronizedTest, "t5");
        thread.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

结果：
t1---count:4
t2---count:3
t3---count:2
t4---count:1
t5---count:0

加上synchronized

 @Override
    public synchronized void run() {
        count --;
        System.out.println(Thread.currentThread().getName() + "---count:" + count);
    }


t1---count:4
t5---count:3
t4---count:2
t3---count:1
t2---count:0

synchronized是以把锁，当多个线程访问方法时，会以排队的方式进行处理（根据CPU分配，所以上面线程并不是按12345的顺序），线程访问时，会先尝试拿锁，如果拿到锁，就执行synchronized方法，如果拿不到，就会不断尝试去拿锁，直到拿到为止。而且是多个线程竞争拿锁。

3、锁（对象锁、独占锁）

public class SynchronizedTest2 {

    public synchronized void print(String name) {
        int type = 0;
        if (name.equals("张三")) {
            type = 1;
            System.out.println("name:" + name + "  type:" + type);
        } else {
            type = 2;
            System.out.println("name:" + name + "  type:" + type);
        }
        System.out.println("hello, I'm is " + name);
    }

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

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                test1.print("张三");
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                test2.print("李四");
            }
        });

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

结果：
name:李四  type:2
name:张三  type:1
hello, I'm is 李四
hello, I'm is 张三

从结果看，print()并没有被锁，因为我们希望是打印name时，hello也紧跟着打印，但是上面的情况明显没锁到。究竟是怎么呢？

是因为两个线程t1,t2执行的锁不是一把锁，等于有两个人，各进到两个厕所里，并没有任何冲突，如果再来一个人，到另外第三个厕所。 所以这时，需要在方法上加static，方法加static后，方法锁属于类对象，那么类下的所以对象拥有一把锁

public static synchronized void print(String name) {
        int type = 0;
        if (name.equals("张三")) {
            type = 1;
            System.out.println("name:" + name + "  type:" + type);
        } else {
            type = 2;
            System.out.println("name:" + name + "  type:" + type);
        }
        System.out.println("hello, I'm is " + name);
    }

name:张三  type:1
hello, I'm is 张三
name:李四  type:2
hello, I'm is 李四

这时的锁属于独占锁，静态方法加synchornized锁，属于类级别锁，无论实例化多个对象，都是一把锁。非静态的都是对象锁

 

4、对象锁的同步、异步

同步：访问加了synchronized的方法或代码块

public class SychonirzedTest3 {

    public synchronized void method1() {
        System.out.println("线程名称:" + Thread.currentThread().getName());
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public  void method2() {
        System.out.println("线程名称:" + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        final SychonirzedTest3 test = new SychonirzedTest3();
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                test.method1();
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                test.method2();
            }
        });

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

上面定义了一个同步方法、异步方法

我们在method1()加了同步，并休眠5秒，结果发现：method1()执行完了，马上执行method2(),说明这两个互不影响，但是如果我在method2()上加了同步，就会出现必须线程1休眠5秒后才执行，这就是对象锁同步

5、同步要注意几点：setValue/getValue都要保证synchronized,避免脏读；可重入，比如父类方法用了，子类也要用，方法嵌套可以以用

6、synchronized代码块，有时一个synchronized方法需要执行很长时间，那其他线程就需要等候很长时间，这时可以使用代码块，减小锁的粒度

public void method2() {
    synchronized (SynchronizedCode.class) {
        for (int i=0; i<5; i++) {
            System.out.println(Thread.currentThread().getName() + "  method2");
        }
    }
}


public void method3() {
    synchronized (this) {
        System.out.println(Thread.currentThread().getName() + "  method2");
    }
}

public static void main(String[] args) {
        final SynchronizedCode synchronizedCode = new SynchronizedCode();

//        for (int i=0; i<5; i++) {
            Thread thread = new Thread(new Runnable() {
                public void run() {
                    synchronizedCode.method1();
                }
            }, "name" + 1);
            thread.start();
//        }

//        for (int i=0; i<5; i++) {
            Thread thread2 = new Thread(new Runnable() {
                public void run() {
                    synchronizedCode.method2();
                }
            }, "name2" + 2);
            thread2.start();
//        }
    }

synchronized(this)指的是调用该方法的引用，对应上面代码的synchronizedCode

synchronized(SynchronizedTest.class):指的是类本身，这种与在synchronized方法上加static一样，独立锁

 

转载于:https://my.oschina.net/u/2504766/blog/757517