Java 在并发类的run（）方法中放置什么？

假设我们有一个名为Teacher的线程安全类，它实现了Runnable。老师可以读学生的书，也可以写学生的书

public class Teacher implements Runnable {

boolean doneWithBook = false;
private Lock lock = new ReentrantLock();
private Condition cond = lock.newCondition();

public void readBook(Book book) {

    lock.lock();
    try {
        book.read();
        doneWithBook = false;
        cond.signalAll();
        System.out.println("Teacher read the book");
    } finally {
        lock.unlock();
    }
}

public void writeToBook(Book book) {

    lock.lock();
    try {
        book.write();
        doneWithBook = true;
        System.out.println("Teacher wrote to book.");
    } finally {
        lock.unlock();
    }
}

教师实现Runnable，因此任务可以在其自己的单独线程上运行。我不明白的是在Runnable的接口run（）方法中放什么。如果我想读/写这本书怎么办。run（）是如何发挥作用的？我们非常欣赏这些例子

@Override
public void run() {

  // now what???

}

如果我想读/写这本书怎么办。run（）是如何发挥作用的

所以有两种方法可以做到这一点。最简单的方法是在

run（）

方法中基于某种构造函数参数设置

if

：

private final boolean reading;
public Teacher(boolean reading) {
    this.reading = reading;
}
public void run() {
    if (reading) {
       readBook(book);
    } else {
       writeToBook(book);
    }
}

但是，如果读写代码不共享任何代码，那么我将有一个

ReadingTeacher

类和一个

WritingTeacher

类，它们做不同的事情。然后你会做一些类似的事情：

public class ReadingTeacher implements Runnable {
    ...
    public void run() {
        readBook(book);
    }
}

所有这一切都说明，我相信你的问题是有条件的。如果有两个不同的

Runnable

对象，它们需要共享相同的条件。Te条件应该在线程之外创建，并传递给构造函数。然后，阅读教师可以在写作教师正在等待的同一个条件对象上发出信号

 public class Teacher implements Runnable {
      private final boolean reading;
      private final Condition cond;
      public Teacher(boolean reading, Condition cond) {
          this.reading = reading;
          this.cond = cond;
      }
      public void run() {
          if (reading) {
              readBook(book);
          } else {
              writeToBook(book);
          }
      }
 }
 ...
 Condition cond = lock.newCondition();
 new Thread(new Teacher(true, cond)).start();
 new Thread(new Teacher(false, cond)).start();

一个更简单的解决方案是将

条件cond

设为

静态

，这样所有实例共享相同的条件，尽管这不是一个好的模式

如果我想读/写这本书怎么办。run（）是如何发挥作用的

所以有两种方法可以做到这一点。最简单的方法是在

run（）

方法中基于某种构造函数参数设置

if

：

private final boolean reading;
public Teacher(boolean reading) {
    this.reading = reading;
}
public void run() {
    if (reading) {
       readBook(book);
    } else {
       writeToBook(book);
    }
}

但是，如果读写代码不共享任何代码，那么我将有一个

ReadingTeacher

类和一个

WritingTeacher

类，它们做不同的事情。然后你会做一些类似的事情：

public class ReadingTeacher implements Runnable {
    ...
    public void run() {
        readBook(book);
    }
}

所有这一切都说明，我相信你的问题是有条件的。如果有两个不同的

Runnable

对象，它们需要共享相同的条件。Te条件应该在线程之外创建，并传递给构造函数。然后，阅读教师可以在写作教师正在等待的同一个条件对象上发出信号

 public class Teacher implements Runnable {
      private final boolean reading;
      private final Condition cond;
      public Teacher(boolean reading, Condition cond) {
          this.reading = reading;
          this.cond = cond;
      }
      public void run() {
          if (reading) {
              readBook(book);
          } else {
              writeToBook(book);
          }
      }
 }
 ...
 Condition cond = lock.newCondition();
 new Thread(new Teacher(true, cond)).start();
 new Thread(new Teacher(false, cond)).start();

一个更简单的解决方案是将

条件cond

设为

静态

，这样所有实例共享相同的条件，尽管这不是一个好的模式

如果我想读/写这本书怎么办。run（）是如何发挥作用的

所以有两种方法可以做到这一点。最简单的方法是在

run（）

方法中基于某种构造函数参数设置

if

：

private final boolean reading;
public Teacher(boolean reading) {
    this.reading = reading;
}
public void run() {
    if (reading) {
       readBook(book);
    } else {
       writeToBook(book);
    }
}

但是，如果读写代码不共享任何代码，那么我将有一个

ReadingTeacher

类和一个

WritingTeacher

类，它们做不同的事情。然后你会做一些类似的事情：

public class ReadingTeacher implements Runnable {
    ...
    public void run() {
        readBook(book);
    }
}

所有这一切都说明，我相信你的问题是有条件的。如果有两个不同的

Runnable

对象，它们需要共享相同的条件。Te条件应该在线程之外创建，并传递给构造函数。然后，阅读教师可以在写作教师正在等待的同一个条件对象上发出信号

 public class Teacher implements Runnable {
      private final boolean reading;
      private final Condition cond;
      public Teacher(boolean reading, Condition cond) {
          this.reading = reading;
          this.cond = cond;
      }
      public void run() {
          if (reading) {
              readBook(book);
          } else {
              writeToBook(book);
          }
      }
 }
 ...
 Condition cond = lock.newCondition();
 new Thread(new Teacher(true, cond)).start();
 new Thread(new Teacher(false, cond)).start();

一个更简单的解决方案是将

条件cond

设为

静态

，这样所有实例共享相同的条件，尽管这不是一个好的模式

如果我想读/写这本书怎么办。run（）是如何发挥作用的

所以有两种方法可以做到这一点。最简单的方法是在

run（）

方法中基于某种构造函数参数设置

if

：

private final boolean reading;
public Teacher(boolean reading) {
    this.reading = reading;
}
public void run() {
    if (reading) {
       readBook(book);
    } else {
       writeToBook(book);
    }
}

但是，如果读写代码不共享任何代码，那么我将有一个

ReadingTeacher

类和一个

WritingTeacher

类，它们做不同的事情。然后你会做一些类似的事情：

public class ReadingTeacher implements Runnable {
    ...
    public void run() {
        readBook(book);
    }
}

所有这一切都说明，我相信你的问题是有条件的。如果有两个不同的

Runnable

对象，它们需要共享相同的条件。Te条件应该在线程之外创建，并传递给构造函数。然后，阅读教师可以在写作教师正在等待的同一个条件对象上发出信号

 public class Teacher implements Runnable {
      private final boolean reading;
      private final Condition cond;
      public Teacher(boolean reading, Condition cond) {
          this.reading = reading;
          this.cond = cond;
      }
      public void run() {
          if (reading) {
              readBook(book);
          } else {
              writeToBook(book);
          }
      }
 }
 ...
 Condition cond = lock.newCondition();
 new Thread(new Teacher(true, cond)).start();
 new Thread(new Teacher(false, cond)).start();

---

一个更简单的解决方案是将

条件cond

设置为

静态

，使所有实例共享相同的条件，尽管这不是一个好的模式。

好的，一般来说，实现

可运行

的是您的任务，因此在您的情况下，您可能会有以下情况：

public ReadTask implements Runnable
{
  private Teacher teacher;

  public ReadTask(Teacher teacher)
  {
    this.teacher = teacher;
  }

  public void run()
  {
    teacher.readBook();
  }
}

public WriteTask implements Runnable
{
  private Teacher teacher;

  public WriteTask (Teacher teacher)
  {
    this.teacher = teacher;
  }

  public void run()
  {
    teacher.writeToBook();
  }
}

那么您调用的代码如下所示：

Teacher teacher = ...
new Thread(new ReadTask(teacher)).start();
new Thread(new WriteTask(teacher)).start();

---

还要注意的是，代码中的

条件

并没有真正实现任何功能。

好的，一般来说，是您的任务实现了

可运行

，因此在您的情况下，您可能会遇到以下问题：

public ReadTask implements Runnable
{
  private Teacher teacher;

  public ReadTask(Teacher teacher)
  {
    this.teacher = teacher;
  }

  public void run()
  {
    teacher.readBook();
  }
}

public WriteTask implements Runnable
{
  private Teacher teacher;

  public WriteTask (Teacher teacher)
  {
    this.teacher = teacher;
  }

  public void run()
  {
    teacher.writeToBook();
  }
}

那么您调用的代码如下所示：

Teacher teacher = ...
new Thread(new ReadTask(teacher)).start();
new Thread(new WriteTask(teacher)).start();

---

还要注意的是，代码中的

条件

并没有真正实现任何功能。

好的，一般来说，是您的任务实现了

可运行

，因此在您的情况下，您可能会遇到以下问题：

public ReadTask implements Runnable
{
  private Teacher teacher;

  public ReadTask(Teacher teacher)
  {
    this.teacher = teacher;
  }

  public void run()
  {
    teacher.readBook();
  }
}

public WriteTask implements Runnable
{
  private Teacher teacher;

  public WriteTask (Teacher teacher)
  {
    this.teacher = teacher;
  }

  public void run()
  {
    teacher.writeToBook();
  }
}

那么您调用的代码如下所示：

Teacher teacher = ...
new Thread(new ReadTask(teacher)).start();
new Thread(new WriteTask(teacher)).start();

---

还要注意的是，代码中的

条件

并没有真正实现任何功能。

好的，一般来说，是您的任务实现了

可运行

，因此在您的情况下，您可能会遇到以下问题：

public ReadTask implements Runnable
{
  private Teacher teacher;

  public ReadTask(Teacher teacher)
  {
    this.teacher = teacher;
  }

  public void run()
  {
    teacher.readBook();
  }
}

public WriteTask implements Runnable
{
  private Teacher teacher;

  public WriteTask (Teacher teacher)
  {
    this.teacher = teacher;
  }

  public void run()
  {
    teacher.writeToBook();
  }
}

那么您调用的代码如下所示：

Teacher teacher = ...
new Thread(new ReadTask(teacher)).start();
new Thread(new WriteTask(teacher)).start();

---

还要注意的是，代码中的

条件

并没有真正实现任何功能。

难道你不想要独立的读写线程吗？为什么你认为老师需要实现

可运行

呢？@C.B.读写独立线程之间的区别是什么，与在同一个类中运行相比？@NickHolt我想在单独的线程上运行它，而不是在主线程上。我怎样才能运行它