Java中synchronized关键字实现线程同步互斥-演道网

Java多线程程序现在很常见,和数据库操作系统一样,多个线程会共享一个堆内存,如果不加以控制,不进行线程之间的同步,会造成数据混乱等。

先看看下面这个程序:

public class TestSynchronized implements Runnable {
 Timer timer = new Timer();

 public static void main(String args[]) {
  TestSynchronized test = new TestSynchronized();
  Thread t1 = new Thread(test);
  Thread t2 = new Thread(test);
  t1.setName(“t1”);
  t2.setName(“t2”);
  t1.start();
  t2.start();
 }

 public void run() {
  timer.add(Thread.currentThread().getName());
 }
}

class Timer {
 private static int num = 0;

 public void add(String name) {
  // synchronized(this){ //没有同步,将导致num的数目不正常
  num++;
  try {
   Thread.sleep(1);
  } catch (Exception e) {
  }
  System.out.println(name + “, 你是第” + num + “个使用timer的线程”);
  // }
 }
}输出的结果:

t1, 你是第2个使用timer的线程
t2, 你是第2个使用timer的线程

num两次都是2。这里很明显是两个线程在访问同一个Timer对象的num变量时交替进行,所以最后打印的时候都是2;

如何实现不同线程之间互斥访问这个num呢,使用synchronized同步代码块即可解决,用synchronized(this){}将需要同步代码块圈起来。

输出正常结果:

t2, 你是第1个使用timer的线程
t1, 你是第2个使用timer的线程

 

synchronized的另一个用法是同步方法,就是在方法之前加上修饰符synchronized。那么不同线程在访问同一个对象的synchronized方法时就会互斥访问,从而达到同步

下面是一个经典的生产消费者模型代码:

public class TestSynchronized {
 public static void main(String[] args) {
  SyncStack ss = new SyncStack();
  Producer p = new Producer(ss);
  Consumer c = new Consumer(ss);
  Thread tp = new Thread(p);
  Thread tc = new Thread(c);
  tp.start();
  tc.start();
 }
}

class Bread {
 int id;

 Bread(int id) {
  this.id = id;
 }

 public String toString() {
  return “Bread: ” + id;
 }
}

class SyncStack {
 int index = 0;
 Bread[] breads = new Bread[6];

 public synchronized void push(Bread b) {
  if (index == breads.length) {// 注意只能用while不能用if;因为wait会异常
   try {
    this.wait();// 访问当前对象的线程wait()
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  this.notify();
  breads[index] = b;
  index++;
  System.out.println(“生产了:” + b);
 }

 public synchronized Bread pop() {
  if (index == 0) {
   try {
    this.wait();// wait的时候锁已经不归该线程所有,但是sleep还有锁
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  this.notify();// 叫醒一个正在该对象上wait的一个线程
  index–;
  System.out.println(“消费了:” + breads[index]);
  return breads[index];
 }
}

class Producer implements Runnable {
 SyncStack ss = null;

 Producer(SyncStack ss) {
  this.ss = ss;
 }

 public void run() {
  for (int i = 0; i < 20; i++) {
   Bread b = new Bread(i);
   ss.push(b);
   // System.out.println(“生产了:”+b);
   try {
    Thread.sleep((int) Math.random() * 1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}

class Consumer implements Runnable {
 SyncStack ss = null;

 Consumer(SyncStack ss) {
  this.ss = ss;
 }

 public void run() {
  for (int i = 0; i < 20; i++) {
   Bread b = null;
   b = ss.pop();
   // System.out.println(“消费了:”+breads[index]);//放到这里用if的话会出问题,先打出消费0,再打出生产0
   try {
    Thread.sleep((int) Math.random() * 1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}

同步栈对象SyncStack的push和pop方法就是同步方法。生产者线程和消费者线程将会互斥访问pop和push方法。

Java中synchronized关键字实现线程同步互斥

下面说一下这种同步机制的实现。java为每个类对象分配一个独一无二的对象锁,每个线程要访问这个对象的成员就需要获得这个锁(当然这里是指需要同步的线程)。因为一个对象只有一个对象锁,所以一个线程在拿到锁之后,另一个访问相同对象的线程必须等待前者执行完成后释放掉对象锁,以此实现互斥。也就是说synchronized是针对对象的,不是针对类的。看看上面的图形。ObjectA和ObjectB是同一个类的不同实例,所以ThreadAn和ThreadBn没有关系。只有ThreadA1234同步,ThreadB1234亦是如此。并且对于非synchronized的方法和代码块,并没有影响,没有互斥

那有没有实现类级别上的同步呢?有的。在 Java 中,不光是类实例,每一个类也对应一把锁,这样我们也可将类的静态成员函数声明为 synchronized ,以控制其对类的静态成员变量的访问。  使用同步代码块是synchronized(classname.class){}

最后几点总结:

1)是某个对象实例内,synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法(如果一个对象有多个synchronized方法,只要一个线程访问了其中的一个synchronized方法,其它线程不能同时访问这个对象中任何一个synchronized方法)。这时,不同的对象实例的synchronized方法是不相干扰的。也就是说,其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法;
2)是某个类的范围,synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
2、除了方法前用synchronized关键字,synchronized关键字还可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/},它的作用域是当前对象;
3、synchronized关键字是不能继承的,也就是说,基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){},而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法;

对synchronized(this)的一些理解

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执      行完这个代码块以后才能执行该代码块。 

二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。 

三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被      阻塞。 

四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结          果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。 

五、以上规则对其它对象锁同样适用

更多详情

转载自演道,想查看更及时的互联网产品技术热点文章请点击http://go2live.cn