一、如果每个线程执行的代码相同，可以使用同一个Runnable 对象，这个Runnable对象中有那个共享的数据，例如买票系统就可以这样做。
代码如下：
package com.thread;
class ShareDataTest1 {
public static void main(String[] args) {
ShareData sd=new ShareData();
for(int i=0;i<=20;i++){
Thread t1=new Thread(sd,"窗口1");
t1.start();
Thread t2=new Thread(sd,"窗口2");
t2.start();
Thread t3=new Thread(sd,"窗口3");
t3.start();
Thread t4=new Thread(sd,"窗口4");
t4.start();
}
}
}
class ShareData implements Runnable{
private int count=100;// 共100个车票
@Override
public void run() {
synchronized (ShareData.class) {
count--; //每次出一个车票
System.out.println(Thread.currentThread().getName()+"卖出一个车票,剩余车票 "+count+" 个");
}
}
}
输出结果：
窗口1卖出一个车票,剩余车票 99 个
窗口3卖出一个车票,剩余车票 98 个
窗口2卖出一个车票,剩余车票 97 个
窗口4卖出一个车票,剩余车票 96 个
窗口1卖出一个车票,剩余车票 95 个
窗口2卖出一个车票,剩余车票 94 个
窗口3卖出一个车票,剩余车票 93 个
窗口1卖出一个车票,剩余车票 92 个
窗口3卖出一个车票,剩余车票 91 个
窗口1卖出一个车票,剩余车票 90 个
窗口3卖出一个车票,剩余车票 89 个
窗口1卖出一个车票,剩余车票 88 个
窗口3卖出一个车票,剩余车票 87 个
窗口1卖出一个车票,剩余车票 86 个
二、如果每个线程执行的代码不同，这时候需要用不同的Runnable对象，有如下两种方式来实现这些Runnable对象之间的数据共享：
(1) 将共享数据封装在另外一个对象中，然后将这个对象逐一传递给各个Runnable 对象。每个线程对共享数据的操作方法也分配到那个对象上去完成，这样容易实现针对该数据进行的各个操作的互斥和通信。
package com.thread;
public class ShareDataTest2 {
public static void main(String[] args) {
ShareData1 data1=new ShareData1();
for(int i=0;i<=10;i++){
new Thread(new Inc(data1)).start();
new Thread(new Dec(data1)).start();
}
}
}
class ShareData1{
private int count=0;//共享数据
public synchronized void increment(){
++count;
System.out.println("执行increment()方法 count:"+count);
}
public synchronized void decrement(){
--count;
System.out.println("执行decrement()方法 count:"+count);
}
}
class Inc implements Runnable{
private ShareData1 data1;
public Inc(ShareData1 data1) {
this.data1=data1;
}
@Override
public void run() {
data1.increment();
}
}
class Dec implements Runnable{
private ShareData1 data1;
public Dec(ShareData1 data1) {
this.data1=data1;
}
@Override
public void run() {
data1.decrement();
}
}
(2) 将这些Runnable对象作为某一个类中的内部类，共享数据作为这个外部类中的成员变量，每个线程对共享数据的操作方法也分配给外部类，以便实现对共享数据进行的各个操作的互斥通信，作为内部类的各个Runnable对象调用外部类的这些方法.
package com.thread;
public class ShareDataTest3 {
private int count;
public static void main(String[] args) {
ShareDataTest3 sdt=new ShareDataTest3();
new Thread(sdt.new Inc()).start();
new Thread(sdt.new Dec()).start();
}
//内部类
class Inc implements Runnable{
@Override
public void run() {
increment();
}
}
class Dec implements Runnable{
@Override
public void run() {
decrement();
}
}
// 公共方法
public synchronized void increment(){
++count;
System.out.println("执行increment()方法 count:"+count);
}
public synchronized void decrement(){
--count;
System.out.println("执行decrement()方法 count:"+count);
}
}
(3) 以上两种方式的组合：将共享数据封装在另一个对象中，每个线程对共享数据的操作方法也分配到那个对象上去完成，对象作为这个外部类中的成员变量或方法中的局部变量，每个线程的Runnable对象作为外部类的成员内部类或局部内部类。
package com.thread;
public class ShareDataTest4 {
public ShareData4 shareData4=new ShareData4();
public static void main(String[] args) {
ShareDataTest4 sd=new ShareDataTest4();
new Thread(sd.new Inc()).start();
new Thread(sd.new Dec()).start();
}
//内部类
class Inc implements Runnable{
@Override
public void run() {
shareData4.increment();
}
}
class Dec implements Runnable{
@Override
public void run() {
shareData4.decrement();
}
}
}
class ShareData4{
public int count;
// 公共方法
public synchronized void increment(){
++count;
System.out.println("执行increment()方法 count:"+count);
}
public synchronized void decrement(){
--count;
System.out.println("执行decrement()方法 count:"+count);
}
}
(4) 总之，要同步互斥的几段代码最好是分别放在几个独立的方法中，这些方法再放在同一个类中，这样比较容易实现他们之间的同步互斥和通信。
三、极端且简单的方式，即在任意一个类中定义一个static的变量，这将被所有线程共享。
以上就是多线程共享的方式.
下面我们来看下，网上的的一个面试题:
设计4个线程，其中两个线程每次对 j 增加1，另外两个线程对 j 减少1 写出程序。
package com.thread;
public class ShareDataTest5 {
ShareData5 data=new ShareData5();
public static void main(String[] args) {
ShareDataTest5 sdt=new ShareDataTest5();
sdt.call();
}
public void call(){
for(int i=0;i<2;i++){
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<100;i++){
data.dec();
}
}
},"减少").start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<100;i++){
data.inc();
}
}
},"增加").start();
}
}
}
class ShareData5{
private int j=0;
public synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec :"+j);
}
public synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc :"+j);
}
}
