多线程并发求教
例:
A转账给B,
C转账给B.
........
入库操作.
1.需要效率,不能把没有冲突的人给锁住,比如:e转账给f,这个时候,ab,ef同时进行,对于A->b做完后才能C->B.
2.暂时想法是把正在进行的人员放入到一个静态的map中(成对放入,比如A,B),
每次先检查要处理的人是否有其中一个正在处理,如果正在处理,那么循环等.如果正在处理的人,处理完了,那么就从map中移除出去,后来的C->B就放入....依次循环..
但如果真的并发了那么放入map的时候可能出现并发,但我不能去锁方法,锁方法就违背了第一个.
其实也不止放的时候,判断map是否存在该人,放入时,删除时,都存在并发的问题.
谁有并发的处理经验?求教.
以这个例子再次说明下:
A->B
C->B
E->F
期望,如果三对同时做的话,那么a,b和e,f先处理,c,b等待.
但愿大家明白我意思.
[解决办法]
楼主可以去看下java.util.concurrent.locks包下的
Lock类和Condition类jdk 1.5新线程同步类。
[解决办法]
其实我觉得从理论上来说，这种既能兼顾效率又能兼顾一致性的并发解决方案并不存在，因为计算机无论任何的逻辑判断过程都是需要时间复杂度的，这是肯定的，只要有时间复杂度，就一定存在并发问题，要解决并发，就必须要加锁，这是没有商量的，但是第一条又要求不能对无影响的用户加锁，如何判断有没有影响呢？当然是通过程序，但是程序又需要时间来执行，执行过程中又会有并发......这是一个悖论
[解决办法]
public interface Transfer {
void action(Transfer transfer);
}
public class TransferImp implements Transfer {
public synchronized action(Transfer transfer) {
synchronized (transfer) {
...
}
}
}
public class TransferThread implements Runnable {
private Transfer from;
private Transfer to;
public TransferThread(Transfer from, Transfer to) {
this.from = from;
this.to = to;
}
public void run() {
from.action(to);
}
}
public class Test {
public void static main(String[] args) {
// 如果是Web环境下你只要将地下申明的a,b,c,e,f对象放入全局就行（如static,application,session等），根据你实际情况
Transfer a = new TransferImp();
Transfer b = new TransferImp();
Transfer c = new TransferImp();
Transfer e = new TransferImp();
Transfer f = new TransferImp();
Thread t1 = new Thread(new TransferThread(a,b));
Thread t2 = new Thread(new TransferThread(c,b));
Thread t3 = new Thread(new TransferThread(e,f));
t1.start();
t2.start();
t3.start();
}
}
public class Translate extends Thread{
private Person p1;
private Person p2;
private int money;
public Translate(Person p1, Person p2, int money) {
this.p1 = p1;
this.p2 = p2;
this.money = money;
}
@Override
public void run() {
try {
p1.del(money);
p2.add(money);
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Person pA = new Person("A", 200);
Person pB = new Person("B", 200);
Person pC = new Person("C", 200);
Person pD = new Person("D", 200);
Translate t1 = new Translate(pA, pB, 20);
Translate t2 = new Translate(pC, pB, 20);
Translate t3 = new Translate(pC, pD, 20);
t1.start();
t2.start();
t3.start();
}
}
class Person {
private double account;
private String name;
public Person(String name, double account) {
this.account = account;
this.name = name;
}
public synchronized void add(double money) throws InterruptedException {
account += money;
printMenoy("add");
Thread.sleep(2000); // 处理时间，通过这来看出其他线程的阻塞
}
public synchronized void del(double money) throws InterruptedException {
account -= money;
printMenoy("delete");
}
public void printMenoy(String deal) {
System.out.println("Deal with: " + deal + " -- " + name + "'s money :" + account);
}
}
