3

假设我们有这些类：

public  class Record {
    int key;
    int value;
    Record(){
        this.key=0;
        this.value=0;
    }
    Record(int key,int value){
        this.key=key;
        this.value=value;
    }
    public  class Table {
        static final Record[] table = new Record [100];
        static final Object[] locks = new Object[table.length];
        static{
        for(int i = 0; i < table.length; i++) {
            locks[i] = new Object();
        }


        table[0]=new Record(0,0);
        table[1]=new Record(1,10); 
        table[2]=new Record(2,20);
        table[3]=new Record(3,30);
    }
}

我想在 TRansaction 类中实现这些方法

void setValueByID(int key, int value)

键值对（记录）被锁定（不能从其他事务读取/写入），直到 setValueByID 方法完成。

int getValueByID(int key)

键值对（记录）被锁定直到事务提交

void commit()

它解锁当前事务中锁定的所有键值对（记录）

所以，我的实现是：

class Transaction extends Thread {
//there is no problem here  
    public void setValueByID(int key, int value){

    synchronized(Table.locks[key]) {
     Table.table[key].key=key;

    }   
    }
    //the problem is here...
    //how can i make other thread wait until current thread calls Commit()
    public int getValueByID(int key){
            int value=0; 
            synchronized(Table.locks[key]){
            value= Table.table[key].key;
     }
     return value;
} 


void commit(){
}

艾哈迈德

4

3 回答 3

2

您不能使用同步块来实现它，而是需要使用锁之类的东西。

public Main {
    public static void main(String[] args) {
        final Transaction T = new Transaction();
        for (int n = 0; n < 10; n++) {
            new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        T.setValueByID(i % 100, i);
                        T.getValueByID(i % 100);
                        if (i % 20 == 0) T.commit();
                    }
                }  
            }).start();
        }
    }
}
class Table {
    static final Record[] table = new Record[100];
    static final ReentrantLock[] locks = new ReentrantLock[table.length];

    static {
        for (int i = 0; i < table.length; i++) {
            locks[i] = new ReentrantLock();
        }

        table[0] = new Record(0, 0);
        table[1] = new Record(1, 10);
        table[2] = new Record(2, 20);
        table[3] = new Record(3, 30);
    }
}
class Transaction {

    private ThreadLocal<Set<ReentrantLock>> locks = new ThreadLocal<Set<ReentrantLock>>() {
        @Override
        protected Set<ReentrantLock> initialValue() {
            return new HashSet<ReentrantLock>();
        }
    };

    private void attainLock(int key) {
        final ReentrantLock lock = Table.locks[key];
        lock.lock();
        locks.get().add(lock);
    }

    private void releaseLock(int key) {
        final ReentrantLock lock = Table.locks[key];
        releaseLock(lock);
    }

    private void releaseLock(ReentrantLock lock) {
        final Set<ReentrantLock> lockSet = locks.get();
        if (!lockSet.contains(lock)) {
            throw new IllegalStateException("");
        }
        lockSet.remove(lock);
        lock.unlock();
    }

    private void releaseLocks() {
        final Set<ReentrantLock> lockSet = new HashSet<ReentrantLock>(locks.get());
        for (ReentrantLock reentrantLock : lockSet) {
            releaseLock(reentrantLock);
        }
    }

    public void setValueByID(int key, int value) {
        attainLock(key);
        Table.table[key].key = key;
        releaseLock(key);
    }

    public int getValueByID(int key) {
        attainLock(key);
        return Table.table[key].key;
    }

    void commit() {
        releaseLocks();
    }
}

锁的问题是，在你的交易过程中，如果你在获得锁的时候没有遵循顺序，你可能会遇到死锁！此外，您需要确保正确处理异常并始终通过调用 commit() 释放锁。

于 2012-04-28T04:28:51.877 回答
1

这种同步是使用wait()/notify()带有某种锁的方法来实现的。在此处阅读有关它们（和其他同步概念）的 Java 教程。

于 2012-04-28T04:23:40.337 回答
0

理想情况下，您需要熟悉 java 并发包的 ReadWriteLock。setValueId应该获得一个写锁并持有它直到事务提交。getValueId只需要一个可以被其他读锁共享并在方法结束时释放的读锁。

还要考虑一些超时，以便不会无限期地持有锁。

研究：

  • 读/写锁定模式
  • 数据库系统中的隔离级别
  • 事务处理
于 2012-04-28T04:26:39.403 回答