同步方法vs Reenter antLock

Question

假设我有一个服务器，它有多个线程，共享对一个数据实例的引用。快点，

编辑1：为了可读性而更新

public void main() {
 Data data = new Data();
 ReentrantLock rl = new ReentrantLock(true);
 ReadThread t1 = new ReadThread(data, rl);
 UploadThread t2 = new UploadThread(data, rl);
 t1.start(); t2.start();
}

class ReadThread extends Thread {
private Data data;
private ReentrantLock lock;

ReadThread(Data d, ReentrantLock l){ data = d; lock = l; }

     void run(){
        lock.lock();
        try{
        data.put(aString)
        } finally { lock.unlock(); }
     }
}

class UploadThread extends Thread {
private Data data;
private ReentrantLock lock;

UploadThread(Data d, ReentrantLock l){ data = d; lock = l; }

     void run(){
        lock.lock();
        try{
        data.put(aString)
        } finally { lock.unlock(); }
     }
}

是使用上面的锁更好，还是同步下面的put方法更好，

class Data {
 private LinkedList<String> data = new LinkedList<String>();
 synchronized void put(String x){ data.add(x); }
}

这很粗糙，

我主要关心的是并发。

使用同步方法，我假设同步将发生在类的“数据”实例/对象上，这是正确的吗？所以一个上传线程可以调用放置过程/方法，一个ReadThread可以并行地做同样的事情。然而，使用折衷锁示例，在任何时候只有一个线程能够执行放置调用？

如果在“Data”类中，我将LinkedList设置为静态，将put方法设置为同步和静态，会发生什么？哪种方法最好？如果我让东西静止，我会失去mut-ex吗？

Answer 1

在Javasynchronized中，节是可重入的。这意味着单个线程可以根据需要多次进入synchronized部分，但新线程只能在没有其他线程的情况下进入。当前在这些节中的线程已获得锁，并且只有在离开所有同步节时才会返回锁。除了通过方法签名声明synchronized，还可以直接在对象上调用synchronized。例如这两种方法具有相同的效果：

synchronized public void foo() {

}

public void foo() {
    synchronized(this) {

    }
}

ReentrantLock与synchronized非常相似，因为一次只有一个线程可以获取锁。如果线程到达锁。lock（）语句它将等待另一个线程解锁锁。如果线程已经拥有锁，它将继续。在一个同步代码块不够的更复杂的情况下，这可能很有用。

如果...我使put方法同步和静态会发生什么？

如果方法是静态同步的，则意味着锁定的是类本身，而不是类的实例。它独立于实例同步方法被锁定。

对于您的代码：

这里最简单的方法是将Data对象转换为线程安全对象。如果您不能编辑这个类的代码，那么一个有效的策略是将对象包装在线程安全包装器中。

interface Foo {
    void bar();
} 
class UnsafeFoo implements Foo {
    @Override bar() { ... }
}
class ThreadSafeFoo implements Foo {
    Foo foo;
    ThreadSafeFoo(Foo foo) { this.foo = foo; } 
    @Override synchronized bar() { foo.bar(); }
}

Foo unsafe = new UnsafeFoo();
Foo safe = new ThreadSafeFoo(unsafe);