Java并发编程(四)锁的使用(上)

锁的作用

  锁是一种线程同步机制,用于实现互斥,当线程占用一个对象锁的时候,其它线程如果也想使用这个对象锁就需要排队。如果不使用对象锁,不同的线程同时操作一个变量的时候,有可能导致错误。让我们做一个测试:

class Entity {
public int value = 0;
}
class IncreaseThread implements Runnable {
@Override
public void run() {
for(int i=0;i < 100000; i++) {
AndOneTest.instance.value++;
}
}
}
public class AndOneTest {
public static Entity instance = new Entity();
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new IncreaseThread());
exec.execute(new IncreaseThread());
exec.shutdown();
Thread.sleep(5000);//等待两个线程执行结束
System.out.println("Value = " + instance.value);
}
}

5秒后输出以下结果,如果重新运行程序,得出的结果还会不同:

Value = 111260

我们创建了两个线程,这两个线程同时对AddOneTest.value执行十万次自增操作,我们期望的值是200000,然而得到的结果却并不是。假设两个线程都要对int value=0变量实现value++操作,value++操作会被虚拟机分成三步执行,

1.读取value当前的值。

2.将这个值加1。

3.将加1的结果写入value变量。

两个线程执行的顺序有可能是:

1.线程一读取value值(0)

2.线程二读取value值(0)

3.线程一将值加1(1)

4.线程二将值加1(1)

5.线程一将结果写入value变量(1)

6.线程二将结果写入value变量(1)

最后两个线程执行的结果是i=1,而不是i=2。因此我们无法得到Value =200000。线程之间的运行顺序的可不预测性会导致我们得不到正确的结果,因此我们需要加锁来保证结果是正确的。

Java内置锁

内置锁使用synchronized关键字定义,synchronized关键字有两种使用方法,一种是作为修饰词定义在方法中代码如下:

public synchronized void test() {
//临界区
}

另一种是指定一个对象,后面接一个代码块,代码如下:

public void test() {
     synchronized(object) {
//临界区
}
}

二者有两个区别:

1. 锁的对象不同,第一种方式获取的是当前对象的锁,相当于synchronized(this){},第二种方法获取的是指定对象的锁。

2. 作用域不同,第一种方式锁的是整个方法,第二种锁的只是代码块内部。

使用锁对上例自增测试的改进,只需要在AndOneTest.instance.value++外面加上如下代码即可:

synchronized(AndOneTest.instance) {
    AndOneTest.instance.value++;
}

  

运行后5秒后输出以下结果:

Value = 200000

这里有个需要注意的地方:1. 所有的锁都对应一个对象,同一个对象锁之间会互斥;2. 不同对象锁之间不会互斥;3. 没有申请锁的方法不和任何对象锁互斥。因此我们需要对哪个对象进行修改的时候就获取哪个对象的锁,这样就可以保证不同的线程不会同时修改这个对象。如果需要对两个对象修改,则应分别获取两个对象的锁,代码如下:

public void change() {
synchronized(instanceA) {
//对instanceA进行修改
}//释放对instanceA的锁
synchronized(instanceB) {
//对instanceB进行修改
}//释放对instanceB的锁
}

当synchronized关键字修饰static方法时,获取的就不是当前对象的锁了,而是类对象锁,因为调用static方法时可能类还没有对象。实际上类锁也有一个对应的对象,它所对应的对象是ClassName.class。这个对象用于存储类信息的,在使用反射的时候经常使用到。

class TargetClass{
public synchronized static void sleepMethod() {
try {
Thread.sleep(3000);//睡3秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("我睡醒了");
}
public synchronized static void getLockMethod() {
synchronized(Target.class) {
System.out.println("我得到了class锁");
}
}
} class ExampleThread implements Runnable {
@Override
public void run() {
TargetClass.sleepMethod();
}
}
public class StaticLockTest {
public static void main(String[] args) throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
exec.execute(new ExampleThread());
exec.shutdown();
Thread.sleep(100);//等待新创建的线程获得锁
TargetClass.getLockMethod();
}
}

3秒钟之后输出以下结果:

我睡醒了

我得到了class锁

执行main()方法的线程我们称之为主线程,此外我们还通过线程池创建了一个新的线程,新线程执行sleepMethod(),主线程执行getLockMethod()。启动新线程后主线程会等待新线程0.1秒,以确保新线程拿到了锁,0.1秒之后,主线程想获得锁,但是锁已经被占用了,只能等到新线程执行完sleepMethod()方法。本例中synchronized static synchronized(TargetClass.class){}等价,获得的都是TargetClass.class对象的锁。

总结

未完待续。

公众号:今日说码。关注我的公众号,可查看连载文章。遇到不理解的问题,直接在公众号留言即可。

上一篇:WPF datagrid AutoGenerateColumns隐藏部分列


下一篇:Linux 安装tomcat