1.如果每个线程执行的代码相同,可以使用同一个Runable对象,这个Runable对象中有那个共享数据,例如卖票系统就可以这样做。
package javaplay.test;
public class MulteThreadShareData {
public static void main(String[] args) {
ShareData shareData = new ShareData();
new Thread(shareData).start();
new Thread(shareData).start();
}
static class ShareData implements Runnable {
int count = 100;
@Override
public void run() {
while (count > 0) {
decrease();
}
}
public synchronized void decrease() {
count--;
System.out.println(Thread.currentThread().getName() + "this count: " + count);
}
}
}
这个示例是错误的,对共享变量的访问必须必须加锁!volatile只能保证可见性,不能保证原子性!
2.如果每个线程执行的代码不相同,这个时候需要用到不同的Runable对象,有如下两种方式实现多个Runable对象中的数据共享。
2.1 将共享数据封装在另外一个对象中,然后将这个对象逐一传递给各个Runnable对象。每个线程对共享数据的操作方法也分配到那个对象身上去完成,这样容易实现针对该数据进行的各个操作的互斥和通信。
package javaplay.test;
public class MulteThreadShareData {
public static void main(String[] args) {
final ShareData shareData = new ShareData();
new Thread(new Decrease(shareData)).start();
new Thread(new Increment(shareData)).start();
}
static class Decrease implements Runnable {
private ShareData shareData;
public Decrease(ShareData shareData) {
this.shareData = shareData;
}
@Override
public void run() {
shareData.decrease();
}
}
static class Increment implements Runnable {
private ShareData shareData;
public Increment(ShareData shareData) {
this.shareData = shareData;
}
@Override
public void run() {
shareData.increment();
}
}
static class ShareData {
int count = 100;
public synchronized void decrease() {
count--;
System.out.println(Thread.currentThread().getName() + "decrease this count: " + count);
}
public synchronized void increment() {
count++;
System.out.println(Thread.currentThread().getName() + "increment this count: " + count);
}
}
}
2.2 将这些Runnable对象作为某一个类中的内部类,共享数据作为这个外部类中的成员变量,每个线程对共享数据的操作方法也分配给外部类,以便实现对共享数据进行的各个操作的互斥和通信,作为内部类的各个Runnable对象调用外部类的这些方法。
package javaplay.test;
public class MulteThreadShareData {
static int count = 100;
public static void main(String[] args) {
new Thread(new Decrease()).start();
new Thread(new Increment()).start();
}
public synchronized static void decrease() {
count--;
System.out.println(Thread.currentThread().getName() + "decrease this count: " + count);
}
public synchronized static void increment() {
count++;
System.out.println(Thread.currentThread().getName() + "increment this count: " + count);
}
static class Decrease implements Runnable {
@Override
public void run() {
decrease();
}
}
static class Increment implements Runnable {
@Override
public void run() {
increment();
}
}
}
2.3 上面两种方式的组合:将共享数据封装在另外一个对象中,每个线程对共享数据的操作方法也分配到那个对象身上去完成,对象作为这个外部类中的成员变量或方法中的局部变量,每个线程的Runnable对象作为外部类中的成员内部类或局部内部类。
package javaplay.test;
public class MulteThreadShareData {
public static void main(String[] args) {
final ShareData shareData = new ShareData();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
shareData.decrease();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
shareData.increment();
}
}
}).start();
}
static class ShareData {
int count = 100;
public synchronized void decrease() {
count--;
System.out.println(Thread.currentThread().getName() + "this count: " + count);
}
public synchronized void increment() {
count++;
System.out.println(Thread.currentThread().getName() + "this count: " + count);
}
}
}
2.4 总之,要同步互斥的几段代码最好是分别放在几个独立的方法中,这些方法再放在同一个类中,这样比较容易实现它们之间的同步互斥和通信。