多个线程访问共享对象和数据的方式

 多个线程访问共享对象和数据的方式

• 如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，买票系统就可以这么做。
• 如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：

• 将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。
• 将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥和通信，作为内部类的各个Runnable对象调用外部类的这些方法。
• 上面两种方式的组合：将共享数据封装在另外一个对象中，每个线程对共享数据的操作方法也分配到那个对象身上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。
• 总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现它们之间的同步互斥和通信

极端且简单的方式，即在任意一个类中定义一个static的变量，这将被所有线程共享。

package com.cubead.concurrent;

import java.util.concurrent.locks.Lock; 

import java.util.concurrent.locks.ReentrantLock;

public class Thread4J {

 static countJ c = new countJ();

 public static void main(String[] args) {

  for (int i = 0; i < 2; i++) {

   new Thread() {

    @Override

    public void run() {

     while (true) {

      c.add();

     }

    }

   }.start();

  }

  for (int i = 0; i < 2; i++) {

   new Thread() {

    @Override

    public void run() {

     while (true) {

      c.min();

     }

    }

   }.start();

  }

 }

}

class countJ {

 int j = 0;

 Lock lock = new ReentrantLock();

 public void add() {

  lock.lock();

  j++;

  System.out.println(Thread.currentThread().getName() + ", j增加1之后等于: " + j);

  lock.unlock();

 }

 public void min() {

  lock.lock();

  j--;

  System.out.println(Thread.currentThread().getName() + ", j减少1之后等于: " + j);

  lock.unlock();

 }

}

• ThreadLocal实现线程范围的共享变量
• 见下页的示意图和辅助代码解释ThreadLocal的作用和目的：用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。
• 每个线程调用全局ThreadLocal对象的set方法，就相当于往其内部的map中增加一条记录，key分别是各自的线程，value是各自的set方法传进去的值。在线程结束时可以调用ThreadLocal.clear()方法，这样会更快释放内存，不调用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。
• ThreadLocal的应用场景：
  • 订单处理包含一系列操作：减少库存量、增加一条流水台账、修改总账，这几个操作要在同一个事务中完成，通常也即同一个线程中进行处理，如果累加公司应收款的操作失败了，则应该把前面的操作回滚，否则，提交所有操作，这要求这些操作使用相同的数据库连接对象，而这些操作的代码分别位于不同的模块类中。
  •  银行转账包含一系列操作： 把转出帐户的余额减少，把转入帐户的余额增加，这两个操作要在同一个事务中完成，它们必须使用相同的数据库连接对象，转入和转出操作的代码分别是两个不同的帐户对象的方法。
  • 例如Strut2的ActionContext，同一段代码被不同的线程调用运行时，该代码操作的数据是每个线程各自的状态和数据，对于不同的线程来说，getContext方法拿到的对象都不相同，对同一个线程来说，不管调用getContext方法多少次和在哪个模块中getContext方法，拿到的都是同一个。
• 实验案例：定义一个全局共享的ThreadLocal变量，然后启动多个线程向该ThreadLocal变量中存储一个随机值，接着各个线程调用另外其他多个类的方法，这多个类的方法中读取这个ThreadLocal变量的值，就可以看到多个类在同一个线程中共享同一份数据。
• 实现对ThreadLocal变量的封装，让外界不要直接操作ThreadLocal变量。
  • 对基本类型的数据的封装，这种应用相对很少见。
  • 对对象类型的数据的封装，比较常见，即让某个类针对不同线程分别创建一个独立的实例对象。
• 实验步骤：
• 1.先在MyThreadLocalData类中定义一个访问权限为public的ThreadLocal类型的变量x，直接对这个x进行读写操作；
• 2.将变量x的访问权限定义为private， MyThreadLocalData上定义相应的set和get方法对向变量x中存储和检索数据；
• 3.将MyThreadLocalData类自身变成一个具有业务功能的对象，每个线程仅能有该类的一个实例对象，即对于不同的线程来说，MyThreadLocalData.getMyData静态方法拿到的对象都不相同，但对于同一个线程来说，不管调用MyThreadLocalData.getMyData多少次和在哪里调用，拿到的都是同一个MyThreadLocalData对象。先将MyThreadLocalData封装成具有业务功能的对象，然后设计getMyData方法的定义，最后定义getMyData方法要操作的ThreadLocal变量和编写具体的代码。
• ThreadLocal类的应用举例：

package com.cubead.concurrent;

import java.util.Random; 

public class ThreadLocalTest {

 public static void main(String[] args) {

  final A a = new A();

  final B b = new B();

  for (int i = 0; i < 5; i++) {

   new Thread() {

    public void run() {

     /*

      * 1. MyThreadLocalData.x.set(new Random().nextInt(10000));

      * System.out.println(Thread.currentThread() + "has put " +

      * MyThreadLocalData.x.get()); a.say(); b.sayHello();

      */

     /*

      * 2. MyThreadLocalData.set(new Random().nextInt(10000));

      * System.out.println(Thread.currentThread() + "has put " +

      * MyThreadLocalData.get()); a.say(); b.sayHello();

      */

     MyThreadLocalData.getMyData().setX(new Random().nextInt(10000));

     System.out.println(Thread.currentThread() + "has put " + MyThreadLocalData.getMyData().getX());

     a.say();

     b.sayHello();

     MyThreadLocalData.clear();

    }

   }.start();

  }

 }

}

class MyThreadLocalData {

 // 1. public static ThreadLocal x = new ThreadLocal();

 /*

  * 2. private static ThreadLocal x = new ThreadLocal(); public static void

  * set(Object val){ x.set(val); }

  *

  * public static Object get(){ return x.get(); }

  */

 private MyThreadLocalData() {

 }

 private static ThreadLocal instanceContainer = new ThreadLocal();

 public static MyThreadLocalData getMyData() {

  MyThreadLocalData instance = (MyThreadLocalData) instanceContainer.get();

  if (instance == null) {

   instance = new MyThreadLocalData();

   instanceContainer.set(instance);

  }

  return instance;

 }

 public static void clear() {

  instanceContainer.remove();

 }

 private Integer x;

 public void setX(Integer x) {

  this.x = x;

 }

 public Integer getX() {

  return x;

 }

}

class A {

 public void say() {

  // 1. System.out.println(Thread.currentThread() + ": A has getted " +

  // MyThreadLocalData.x.get());

  // 2. System.out.println(Thread.currentThread() + ": A has getted " +

  // MyThreadLocalData.get());

  System.out.println(Thread.currentThread() + ": A has getted " + MyThreadLocalData.getMyData().getX());

 }

}

class B {

 public void sayHello() {

  // 1. System.out.println(Thread.currentThread() + ": B has getted " +

  // MyThreadLocalData.x.get());

  // 2. System.out.println(Thread.currentThread() + ": B has getted " +

  // MyThreadLocalData.get());

  System.out.println(Thread.currentThread() + ": B has getted " + MyThreadLocalData.getMyData().getX());

 }

}