1，如果每个线程执行的代码相同，可以使用同一个Runnable对象，这个Runnable对象中有那个共享数据，例如，卖票系统就可以这么做。
public class MulteThreadlShareData {
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);
}
}
}
2，如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，例如，设计4个线程。其中两个线程每次对j增加1，另外两个线程对j每次减1，银行存取款
有两种方法来解决此类问题：
将共享数据封装成另外一个对象，然后将这个对象逐一传递给各个Runnable对象，每个线程对共享数据的操作方法也分配到那个对象身上完成，这样容易实现针对数据进行各个操作的互斥和通信
public class MulteThreadlShareData2 {
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);
}
}
}
将Runnable对象作为一个类的内部类，共享数据作为这个类的成员变量，每个线程对共享数据的操作方法也封装在外部类，以便实现对数据的各个操作的同步和互斥，作为内部类的各个Runnable对象调用外部类的这些方法。
public class MulteThreadlShareData3 {
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();
}
}
}
上面两种方式的结合：将共享数据封装到另一个对象中，各个线程对共享数据操作的方法也分配到那个对象上去完成，对象作为外部类的成员变量或方法的局部变量，每个runnable对象作为外部类中的成员内部类或局部内部类。
public class MulteThreadlShareData1 {
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);
}
}
}