多线程范围内的共享解决方法参考有4中：
1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象
2.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象
3.如果多个线程执行的代码不同，将共享数据作为外部类的final成员变量，将不同的runnable对象作为内部类主动取数据
4.将数据声明为static的方式（）
见如下示例：
1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象
public class MuiltThreadShare {
/**
* 多个线程共享数据方法：
* 1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象
* 2.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象
* 3.如果多个线程执行的代码不同，将共享数据作为外部类的final成员变量，将不同的runnable对象作为内部类主动取数据
*/
public static void main(String[] args) {
//1.方式一
Task1 task1 = new Task1();
new Thread(task1).start();
new Thread(task1).start();
new Thread(task1).start();
}
}
class Task1 implements Runnable{
/**
* 1.如果线程执行的代码相同，多个线程共享同一个runnable对象时，将共享数据放在runnable对象
*/
private int i = 100;
@Override
public void run() {
increase();
decrease();
}
private synchronized void increase(){
try {
Thread.sleep(200);//为了更容易看到线程执行现象
} catch (InterruptedException e) {
e.printStackTrace();
}
i++;
System.out.println(Thread.currentThread().getName() +",num:"+i);
}
private synchronized void decrease(){
i--;
System.out.println(Thread.currentThread().getName() +",num:"+i);
}
运行结果：最终还是100，不同的线程使用共享数据
运行结果 // Thread-0,num:101 // Thread-2,num:102 // Thread-1,num:103 // Thread-2,num:102 // Thread-0,num:101 // Thread-1,num:100
2.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象
public class MuiltThreadDataShare2 {
public static void main(String[] args) {
// 2.如果多个线程执行的代码不同，将共享数据封装到一个对象中，将这个对象逐一传递给各个runnable对象
/**
* 模拟银行转账功能，可以指定存取款金额，账号初始额度100
*/
ShareData data = new ShareData(0);
// 存50元
new Thread(new TaskIncrease(data, 50)).start();
// 取30元
new Thread(new Taskdecrease(data, 30)).start();
// 存20
new Thread(new TaskIncrease(data, 20)).start();
}
}
class Taskdecrease implements Runnable {
public Taskdecrease(ShareData shareData, int num) {
this.shareData = shareData;
this.num = num;
}
private int num;
private ShareData shareData;
@Override
public void run() {
shareData.decrease(num);
}
}
class TaskIncrease implements Runnable {
public TaskIncrease(ShareData shareData, int num) {
this.shareData = shareData;
this.num = num;
}
private ShareData shareData;
private int num;
@Override
public void run() {
shareData.increase(num);
}
}
class ShareData {
public ShareData(int num) {
i = num;
System.out.println("账户进行初始化,金额为：" + num);
}
private int i;
public synchronized void increase(int i) {
try {
Thread.sleep(200);// 为了更容易看到线程执行现象
} catch (InterruptedException e) {
e.printStackTrace();
}
this.i = this.i + i;
System.out.println(Thread.currentThread().getName() + "账户存入" + i + "元,目前账户余额为:" + this.i);
}
public synchronized void decrease(int i) {
this.i = this.i - i;
System.out.println(Thread.currentThread().getName() + "账户取出" + i + "元,目前账户余额为:" + this.i);
}
}
运行结果：
账户进行初始化,金额为：0 Thread-0账户存入50元,目前账户余额为:50 Thread-2账户存入20元,目前账户余额为:70 Thread-1账户取出30元,目前账户余额为:40
3.如果多个线程执行的代码不同，将共享数据作为外部类的final成员变量，将不同的runnable对象作为内部类主动取数据
public class MuiltThreadDataShare3 {
public static void main(String[] args) {
final Data data = new Data();
new Thread(new Runnable() {
@Override
public void run() {
data.decrease(10);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
data.increase(30);
}
}).start();
}
}
class Data {
private int money = 100;
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public synchronized void increase(int i) {
try {
Thread.sleep(200);// 为了更容易看到线程执行现象
} catch (InterruptedException e) {
e.printStackTrace();
}
this.money = this.money + i;
System.out.println(Thread.currentThread().getName() + "账户存入" + i + "元,目前账户余额为:" + this.money);
}
public synchronized void decrease(int i) {
this.money = this.money - i;
System.out.println(Thread.currentThread().getName() + "账户取出" + i + "元,目前账户余额为:" + this.money);
}
}
4.将数据声明为static的方式
public class MuiltThreadDataShare4 {
private static int num = 100;
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
increase(100);
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
decrease(30);
}
}).start();
}
public static synchronized void increase(int i) {
try {
Thread.sleep(200);// 为了更容易看到线程执行现象
} catch (InterruptedException e) {
e.printStackTrace();
}
num = num + i;
System.out.println(Thread.currentThread().getName() + "账户存入" + i + "元,目前账户余额为:" + num);
}
public static synchronized void decrease(int i) {
num = num - i;
System.out.println(Thread.currentThread().getName() + "账户取出" + i + "元,目前账户余额为:" + num);
}
}
完
时间： 2024-08-01 02:36:12