多個線程訪問共享對象和數據的方式
1.如果每個線程執行的代碼相同，可以使用同一個Runnable對象，這個Runnable對象中有那個共享數據，例如，買票系統就可以這么做。
package java_thread;
//=================================================
// File Name : Runnable_demo2
//------------------------------------------------------------------------------
// Author : Common
class MyThread_2 implements Runnable{
private int ticket = 5;
@Override
public void run() { //覆寫Thread類中的run()方法
// TODO 自動生成的方法存根
for (int i=0;i<10;i++){
synchronized (this) { //設置需要同步的操作
if(ticket>0){
try{
Thread.sleep(300);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println("賣票：ticket="+ticket--);
}
}
// this.sale(); //調用同步方法
}
}
// public synchronized void sale(){ //聲明同步方法
// if(ticket>0){
// try{
// Thread.sleep(300);
// }catch(InterruptedException e){
// e.printStackTrace();
// }
// System.out.println("賣票：ticket="+ticket--);
// }
// }
}
//主類
//Function : Thread_demo2
public class Runnable_demo2 {
public static void main(String[] args) {
// TODO 自動生成的方法存根
MyThread_2 mt = new MyThread_2(); //實例化Runnable子類對象
Thread t1 = new Thread(mt); //實例化Thread類對象
Thread t2 = new Thread(mt); //實例化Thread類對象
Thread t3 = new Thread(mt); //實例化Thread類對象
t1.start(); //啟動線程
t2.start(); //啟動線程
t3.start(); //啟動線程
}
}
2.如果每個線程執行的代碼不同，這時候需要用不同的Runnable對象，有如下兩種方式來實現這些Runnable對象之間的數據共享：
方法1：將共享數據封裝在另外一個對象中，然后將這個對象逐一傳遞給各個Runnable對象。每個線程對共享數據的操作方法也分配到那個對象身上去完成，這樣容易實現針對該數據進行的各個操作的互斥和通信。
package java_thread;
public class MultiThreadShareData { //多線程賣票，一個加，一個減
//private static ShareData1 data1 = new ShareData1();
public static void main(String[] args) {
ShareData1 data2 = new ShareData1();
new Thread(new MyRunnable1(data2)).start();
new Thread(new MyRunnable2(data2)).start();
final ShareData1 data1 = new ShareData1();
new Thread(new Runnable(){
@Override
public void run() {
data1.decrement();
}
}).start();
new Thread(new Runnable(){
@Override
public void run() {
data1.increment();
}
}).start();
}
}
class MyRunnable1 implements Runnable{ //線程1
private ShareData1 data1;
public MyRunnable1(ShareData1 data1){
this.data1 = data1;
}
public void run() {
data1.decrement();
}
}
class MyRunnable2 implements Runnable{ //線程2
private ShareData1 data1;
public MyRunnable2(ShareData1 data1){
this.data1 = data1;
}
public void run() {
data1.increment();
}
}
class ShareData1 /*implements Runnable*/{ //共享對象
/* private int count = 100;
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
count--;
}
}*/
private int j = 0;
public synchronized void increment(){
j++;
}
public synchronized void decrement(){
j--;
}
}
方法2：將這些Runnable對象作為某一個類中的內部類，共享數據作為這個外部類中的成員變量，每個線程對共享數據的操作方法也分配給外部類，以便實現對共享數據進行的各個操作的互斥和通信，作為內部類的各個Runnable對象調用外部類的這些方法。
package java_thread;
//設計 4 個線程,其中兩個線程每次對 j 增加 1,另外兩個線程對 j 每次減少 1
public class ThreadTest1{
private int j;
public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();
}
}
private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
}
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
class Inc implements Runnable{ //線程1
public void run(){
for(int i=0;i<5;i++){
inc();
}
}
}
class Dec implements Runnable{ //線程2
public void run(){
for(int i=0;i<5;i++){
dec();
}
}
}
}
上面兩種方式的組合：將共享數據封裝在另外一個對象中，每個線程對共享數據的操作方法也分配到那個對象身上去完成，對象作為這個外部類中的成員變量或方法中的局部變量，每個線程的Runnable對象作為外部類中的成員內部類或局部內部類。
總之，要同步互斥的幾段代碼最好是分別放在幾個獨立的方法中，這些方法再放在同一個類中，這樣比較容易實現它們之間的同步互斥和通信。
3.極端且簡單的方式，即在任意一個類中定義一個static的變量，這將被所有線程共享。
package java_thread;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class ThreadScopeShareData {
private static int data = 0;
private static Map<Thread, Integer> threadData = new HashMap<Thread, Integer>();
public static void main(String[] args) {
for(int i=0;i<2;i++){
new Thread(new Runnable(){
@Override
public void run() {
int data = new Random().nextInt();
System.out.println(Thread.currentThread().getName() + " has put data :" + data);
threadData.put(Thread.currentThread(), data);
new A().get();
new B().get();
}
}).start();
}
}
static class A{
public void get(){
int data = threadData.get(Thread.currentThread());
System.out.println("A from " + Thread.currentThread().getName() + " get data :" + data);
}
}
static class B{
public void get(){
int data = threadData.get(Thread.currentThread());
System.out.println("B from " + Thread.currentThread().getName() + " get data :" + data);
}
}
}
ThreadLocal實現線程范圍的共享變量，ThreadLocal類就相當於一個Map
見下頁的示意圖和輔助代碼解釋ThreadLocal的作用和目的：
1.用於實現線程內的數據共享，即對於相同的程序代碼，多個模塊在同一個線程中運行時要共享一份數據，而在另外線程中運行時又共享另外一份數據。
2.每個線程調用全局ThreadLocal對象的set方法，就相當於往其內部的map中增加一條記錄，key分別是各自的線程，value是各自的set方法傳進去的值。在線程結束時可以調用ThreadLocal.clear()方法，這樣會更快釋放內存，不調用也可以，因為線程結束后也可以自動釋放相關的ThreadLocal變量。
ThreadLocal的應用場景：
1、訂單處理包含一系列操作：減少庫存量、增加一條流水台賬、修改總賬，這幾個操作要在同一個事務中完成，通常也即同一個線程中進行處理，如果累加公司應收款的操作失敗了，則應該把前面的操作回滾，否則，提交所有操作，這要求這些操作使用相同的數據庫連接對象，而這些操作的代碼分別位於不同的模塊類中。
2、銀行轉賬包含一系列操作： 把轉出帳戶的余額減少，把轉入帳戶的余額增加，這兩個操作要在同一個事務中完成，它們必須使用相同的數據庫連接對象，轉入和轉出操作的代碼分別是兩個不同的帳戶對象的方法。
3、例如Strut2的ActionContext，同一段代碼被不同的線程調用運行時，該代碼操作的數據是每個線程各自的狀態和數據，對於不同的線程來說，getContext方法拿到的對象都不相同，對同一個線程來說，不管調用getContext方法多少次和在哪個模塊中getContext方法，拿到的都是同一個。
實驗案例：定義一個全局共享的ThreadLocal變量，然后啟動多個線程向該ThreadLocal變量中存儲一個隨機值，接着各個線程調用另外其他多個類的方法，這多個類的方法中讀取這個ThreadLocal變量的值，就可以看到多個類在同一個線程中共享同一份數據。
實現對ThreadLocal變量的封裝，讓外界不要直接操作ThreadLocal變量。
對基本類型的數據的封裝，這種應用相對很少見。
對對象類型的數據的封裝，比較常見，即讓某個類針對不同線程分別創建一個獨立的實例對象。
package java_thread;
import java.util.Random;
public class ThreadLocalTest {
private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
public static void main(String[] args) {
for(int i=0;i<2;i++){
new Thread(new Runnable(){
@Override
public void run() {
int data = new Random().nextInt();
System.out.println(Thread.currentThread().getName()
+ " has put data :" + data);
x.set(data); //存放與當前線程有關的數據
new A().get();
new B().get();
}
}).start();
}
}
static class A{
public void get(){
int data = x.get();
System.out.println("A from " + Thread.currentThread().getName()
+ " get data :" + data);
}
}
static class B{
public void get(){
int data = x.get();
System.out.println("B from " + Thread.currentThread().getName()
+ " get data :" + data);
}
}
}
使用ThreadLocal實現在線程范圍內共享變量
package java_thread;
import java.util.Random;
public class ThreadLocalTest {
private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
//private static ThreadLocal<MyThreadScopeData> myThreadScopeData = new ThreadLocal<MyThreadScopeData>();
public static void main(String[] args) {
for(int i=0;i<2;i++){
new Thread(new Runnable(){
@Override
public void run() {
int data = new Random().nextInt();
System.out.println(Thread.currentThread().getName()
+ " has put data :" + data);
x.set(data); //存放與當前線程有關的數據
/* MyThreadScopeData myData = new MyThreadScopeData();
myData.setName("name" + data);
myData.setAge(data);
myThreadScopeData.set(myData);*/
MyThreadScopeData.getThreadInstance().setName("name" + data);
MyThreadScopeData.getThreadInstance().setAge(data);
new A().get();
new B().get();
}
}).start();
}
}
static class A{
public void get(){
int data = x.get();
System.out.println("A from " + Thread.currentThread().getName()
+ " get data :" + data);
/* MyThreadScopeData myData = myThreadScopeData.get();;
System.out.println("A from " + Thread.currentThread().getName()
+ " getMyData: " + myData.getName() + "," +
myData.getAge());*/
MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
System.out.println("A from " + Thread.currentThread().getName()
+ " getMyData: " + myData.getName() + "," +
myData.getAge());
}
}
static class B{
public void get(){
int data = x.get();
System.out.println("B from " + Thread.currentThread().getName() + " get data :" + data);
MyThreadScopeData myData = MyThreadScopeData.getThreadInstance();
System.out.println("B from " + Thread.currentThread().getName()
+ " getMyData: " + myData.getName() + "," +
myData.getAge());
}
}
}
class MyThreadScopeData{
private MyThreadScopeData(){} //構造方法私有化
public static /*synchronized*/ MyThreadScopeData getThreadInstance(){
MyThreadScopeData instance = map.get(); //通過map來判斷有沒有其他線程生成實例對象，如果沒有就創建，所以不需要加入synchronized
if(instance == null){
instance = new MyThreadScopeData();
map.set(instance);
}
return instance;
}
//private static MyThreadScopeData instance = null;//new MyThreadScopeData();
private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();//把ThreadLocal封裝在一個類的內部
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
