Question

我正在浏览java提供的关于锁的高级线程部分，我已经开发了代码..

// A simple lock example.
import java.util.concurrent.locks.*;

class LockDemo {
    public static void main(String args[]) {
        ReentrantLock lock = new ReentrantLock();
        new LockThread(lock, "A");
        new LockThread(lock, "B");        
    }
}

// A shared resource.
class Shared {
    static int count = 0;
}

// A thread of execution that increments count.
class LockThread implements Runnable {
    String name;
    ReentrantLock lock;

    LockThread(ReentrantLock lk, String n) {
        lock = lk;
        name = n;       
        new Thread(this).start();
    }

    public void run() {
        System.out.println("Starting " + name);
        try {
            // First, lock count.
            System.out.println(name + " is waiting to lock count.");
            lock.lock();
            System.out.println(name + " is locking count.");
            Shared.count++;
            System.out.println(name + ": " + Shared.count);
            // Now, allow a context switch -- if possible.
            System.out.println(name + " is sleeping.");
            Thread.sleep(1000);
        } catch (InterruptedException exc) {
            System.out.println(exc);
        } finally {
            // Unlock
            System.out.println(name + " is unlocking count.");
            lock.unlock();
        }
    }
}

我的问题是，正如我们在课程LockDemo中看到的那样，我们正在调用

new LockThread(lock, "A"); 
new LockThread(lock, "B");

不能在编码中用简单和完整的术语表达，以便我能掌握更多，请告知如何表达更简单的形式。

Answer 1

当我看到像这样的线程代码时，它总是让我生气。你是对的，这是一个糟糕的例子，它的作用并不像它应该的那么明显。令我烦恼的部分是Runnable使用自己启动一个线程的实现，以及它在构造函数中启动线程的事实。

我会像这样重写它：

// A simple lock example.
import java.util.concurrent.locks.*;

class LockDemo {
    public static void main(String args[]) {
        ReentrantLock lock = new ReentrantLock();
        LockThread lt1 = new LockThread(lock, "A");
        LockThread lt2 = new LockThread(lock, "B");
        Thread t1 = new Thread(lt1);
        Thread t2 = new Thread(lt2);
        t1.start();
        t2.start();
    }
}

// A shared resource.
class Shared {
    static int count = 0;
}

// A thread of execution that increments count.
class LockThread implements Runnable {
    String name;
    ReentrantLock lock;

    LockThread(ReentrantLock lk, String n) {
        lock = lk;
        name = n;       
    }

    public void run() {
        System.out.println("Starting " + name);
        try {
            // First, lock count.
            System.out.println(name + " is waiting to lock count.");
            lock.lock();
            System.out.println(name + " is locking count.");
            Shared.count++;
            System.out.println(name + ": " + Shared.count);
            // Now, allow a context switch -- if possible.
            System.out.println(name + " is sleeping.");
            Thread.sleep(1000);
        } catch (InterruptedException exc) {
            System.out.println(exc);
        } finally {
            // Unlock
            System.out.println(name + " is unlocking count.");
            lock.unlock();
        }
    }
}

现在从main可以更清楚地知道你正在创建两个线程任务（类实现Runnable的对象）并使用它们来启动两个线程。

关于锁定教程

1 个答案: