互联网并发编程之一 线程安全02

多个线程就有多把锁，每个线程都可以拿到自己指定的锁，分别获得锁之后在执行相应的syncronized的方法。

syncronized拿到的锁都是对象锁，锁住的是对象，而不是一段代码。

        示例

       

package com.jc.thread;

public class Thread02 {

public  int num = 0;

public synchronized  void printNum(String tag){

if(tag.equals("a")){

num = 1000;
System.out.println("tag a set num");
}else{
num = 2000;
System.out.println("tag b set num");
}
System.out.println("tag is "+ tag +"num is" + num);
}

public static void main(String[] args) {

final Thread02 thread01 = new Thread02();
final Thread02 thread02 = new Thread02();

//分別拿到的是两个对象的锁
Thread t = new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
thread01.printNum("a");
}
}, "thread1");

Thread t1 = new Thread(new Runnable() {

@Override
public void run() {
// TODO Auto-generated method stub
thread02.printNum("b");
}
}, "thread2");
t.start();
t1.start();

}

}

打印结果如下：

tag a set num

tag b set num

tag is b num is 2000

tag is a num is 1000

并不是我们预期的结果，这个是由于，线程活得的对象锁是不同的，所以相互之间执行并不受影响，如果需要多个线程访问对象的，拿到的是同一把对象的锁，则需要在方法中加上static 关键字

public  static int num = 0;

public  synchronized static void printNum(String tag){

if(tag.equals("a")){

num += 1000;
System.out.println("tag a set num");
}else{
num += 2000;
System.out.println("tag b set num");
}
System.out.println("tag is "+ tag +" num is " + num);
}

打印结果如下：

tag b set num

tag is b num is 2000

tag a set num

tag is a num is 3000

同步的概念就是共享，如果不是资源共享就没有必要进行同步，同步的目的为了是线程安全，线程安全需要满足两个条件：1原子性2.可见性

当两个线程调用一个对象的不同方法，同步的方法是需要等待获取锁的，不同步的方法可以直接调用

示例如下：

package com.jc.thread;

public class Thread03 {

public synchronized void method1(String threadName) {

System.out.println(threadName);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public void method2(String threadName) {

System.out.println(threadName);
}

public static void main(String[] args) {

final Thread03 t = new Thread03();

Thread thread1 = new Thread(new Runnable() {

@Override
public void run() {
t.method1(Thread.currentThread().getName());
}
}, "t1");
Thread thread2 = new Thread(new Runnable() {

@Override
public void run() {
t.method2(Thread.currentThread().getName());
}
}, "t2");

thread1.start();
thread2.start();
}

}
打印结果：
t1

t2

打印间隔，不需要等待两秒，如果需要等待两秒之后打印结果，则是需要两个方法（method1，method2）都需要加上syncronized关键字，衍生出一致性的概念。