疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

传统线程互斥和同步通信


 

   

  传统的线程互斥和同步通信是通过synchronized关键字和wait()、notify()方法来实现的。

  首先介绍下synchronized关键字。

  synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块。

  1. synchronized 方法:通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如:

  public synchronized void accessVal(int newVal);

  synchronized 方法控制对类成员变量的访问:每个类实例对应一把锁,每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行,否则所属线程阻塞,方法一旦执行,就独占该锁,直到从该方法返回时才将锁释放,此后被阻塞的线程方能获得该锁,重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例,其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态(因为至多只有一个能够获得该类实例对应的锁),从而有效避免了类成员变量的访问冲突(只要所有可能访问类成员变量的方法均被声明为 synchronized)。

  在 Java 中,不光是类实例,每一个类也对应一把锁,这样我们也可将类的静态成员函数声明为 synchronized ,以控制其对类的静态成员变量的访问。 synchronized 方法的缺陷:若将一个大的方法声明为synchronized 将会大大影响效率,典型地,若将线程类的方法 run() 声明为synchronized ,由于在线程的整个生命期内它一直在运行,因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中,将其声明为 synchronized ,并在主方法中调用来解决这一问题,但是 Java 为我们提供了更好的解决办法,那就是 synchronized 块。

  2. synchronized 块:通过 synchronized关键字来声明synchronized 块。语法如下:

  1 synchronized(syncObject) {

  2 //允许访问控制的代码

  3 }

  synchronized 块是这样一个代码块,其中的代码必须获得对象 syncObject (如前所述,可以是类实例或类)的锁方能执行,具体机制同前所述。由于可以针对任意代码块,且可任意指定上锁的对象,故灵活性较高。

  注意:在Java中使用synchronized块可以减少对资源的锁定时间,适当的提高系统性能。syncronized锁定的对象要保证是同一个对象,不然不能实现互斥的效果。对入静态方法的互斥,要锁定类的字节码对象,即类名.class。

  举例如下:

  


 

  1 public class TraditionalSynchronized {

  2 public static void main(String[] args) {

  3 final Outputer outputer = new Outputer();

  4 new Thread(new Runnable() {

  5 @Override

  6 public void run() {

  7 while(true){

  8 outputer.outputer("love");

  9 }

  10 }

  11 }).start();

  12 new Thread(new Runnable() {

  13 @Override

  14 public void run() {

  15 while(true){

  16 Outputer.outputer3("hite");

  17 }

  18 }

  19 }).start();

  20

  21 }

  22 }

  23 //打印字符串

  24 class Outputer{

  25 public void outputer(String name){

  26 int len = name.length();

  27 synchronized (Outputer.class) {

  28 for (int i = 0; i < len; i++) {

  29 System.out.print(name.charAt(i));

  30 }

  31 System.out.println();

  32 }

  33

  34 }

  35 public synchronized void outputer2(String name){

  36 int len = name.length();

  37 for (int i = 0; i < len; i++) {

  38 System.out.print(name.charAt(i));

  39 }

  40 System.out.println();

  41 }

  42 public static synchronized void outputer3(String name){

  43 int len = name.length();

  44 for (int i = 0; i < len; i++) {

  45 System.out.print(name.charAt(i));

  46 }

  47 System.out.println();

  48 }

  49 }

  


 

  线程的同步通信是通过Object的wait()和notify()方法来实现的。wait():当前线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待,直到其他线程通过调用 notify 方法,或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。notify():唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待,则会选择唤醒其中一个线程。选择是任意性的,并在对实现做出决定时发生。线程通过调用其中一个 wait 方法,在对象的监视器上等待。

  现在以:实现子线程循环10次,然后主线程循环100次,然后子线程再次循环10次,然后主线程再次循环100次。如此往复50次。这个例子结合线程互斥和线程通信,来加深印象。

  


 

  1 public class TraditionalCommunication {

  2 public static void main(String[] args) {

  3 final Business business = new Business();

  4 new Thread(new Runnable() {

  5 @Override

  6 public void run() {

  7 for (int i = 0; i < 50; i++) {

  8 business.sub(i);

  9 }

  10 }

  11 }).start();

  12 new Thread(new Runnable() {

  13 @Override

  14 public void run() {

  15 for (int i = 0; i < 50; i++) {

  16 business.main(i);

  17 }

  18 }

  19 }).start();

  20 }

  21 }

  22

  23 /**

  24 * 在解决多线程问题是,尽量将线程同步放在类的内部解决,而不是在多线程中进行同步,这样可以简化程序

  25 * @author luchao

  26 *

  27 */

  28 class Business{

  29 private boolean isSubRun = true;

  30 public synchronized void sub(int n){

  31 while(!isSubRun){//这里可以使用if,但是一些程序存在“假唤醒”状态,使用while来多加一次判断,避免“假唤醒”状态

  32 try {

  33 this.wait();

  34 } catch (InterruptedException e) {

  35 e.printStackTrace();

  36 }

  37 }

  38 for (int i = 0; i < 10; i++) {

  39 System.out.println("sub: "+i+" loop of: "+n);

  40 }

  41 isSubRun = false;

  42 this.notify();//唤醒主线程

  43 }

  44 public synchronized void main(int n){

  45 while(isSubRun){

  46 try {

  47 this.wait();

  48 } catch (InterruptedException e) {

  49 e.printStackTrace();

  50 }

  51 }

  52 for (int i = 0; i < 100; i++) {

  53 System.out.println("main: "+i+" loop of: "+n);

  54 }

  55 isSubRun = true;

  56 this.notify();//唤醒子线程

  57 }

  58 }

  


 

  通过上面例子做出如下总结:在做多线程编程是,尽量将线程同步放在类的内部完成,而不是通过线程来进行同步,这样可以简化编程难度。在synchronized方法内部通过while()增加一次判断,增加程序的严谨性。因为,在没有被通知、中断或超时的情况下,线程还可以唤醒一个所谓的虚假唤醒。