用Java8进行线程排序

我有一个简单的程序，两个线程交替打印递增的数字

所以， 第一线程打印：1

第二线程打印：2

第一线程打印：3。。。等等

我可以使用“线程”类来完成这项工作。但我想看看如何使用Executor类来实现这一点

使用以下代码。。。。executor类似乎不起作用。有什么建议吗

代码：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LocksPackagePractice {

    private int i = 0;

    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();  

    Runnable r = () -> {
    for(int x = 0; x < 5; x++){
        printValue();
    }
    printValue(); 
};

    public static void main(String[] args) {

        new LocksPackagePractice().trigger();
    }

    void trigger(){
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(r);
    }

    void printValue(){

        lock.lock();

        try {

            i++;
            System.out.println(Thread.currentThread().getName() + " and value is = " + i);

            condition.signal();         
            condition.await();

        } catch(InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
}

导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.locks.Condition；
导入java.util.concurrent.locks.Lock；
导入java.util.concurrent.locks.ReentrantLock；
公共类锁具包装实践{
私有整数i=0；
ReentrantLock=新的ReentrantLock（）；
Condition Condition=lock.newCondition（）；
可运行r=（）->{
对于（int x=0；x<5；x++）{
printValue（）；
}
printValue（）；
};
公共静态void main（字符串[]args）{
新的LocksPackagePractice（）.trigger（）；
}
无效触发器（）{
ExecutorService=Executors.newFixedThreadPool（2）；
服务执行（r）；
}
void printValue（）{
lock.lock（）；
试一试{
i++；
System.out.println（Thread.currentThread（）.getName（）+），值为=“+i”；
条件。信号（）；
条件wait（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}最后{
lock.unlock（）；
}
}
}

对程序进行了一些更改。运行它并检查它是否解决了混淆问题

public class LocksPackagePractice {
    private int i = 0;
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    Runnable r = () -> {
        printValue();
    };
    public static void main(String[] args) {
        new LocksPackagePractice().trigger();
    }
    void trigger() {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.submit(r);
        for (int i = 0; i < 5; i++) {
            service.execute(r);
        }
    }
    void printValue() {
        lock.lock();
        try {
            i++;
            System.out.println(Thread.currentThread().getName() + " and value is = " + i);
            condition.signal();
            condition.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

---

我不确定，但您需要输入才能订购吗？因为您使用了阻塞操作（锁），在性能方面并不好

此代码：

private AtomicInteger number = new AtomicInteger(0);

  public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(2);

    ForTestApplication testApplication = new ForTestApplication();

    for (int i = 0; i < 100; i++) {
      executor.execute(testApplication::print);
    }

  }

  public void print () {
    System.out.println(Thread.currentThread().getName() + " : " + number.incrementAndGet());
  }

---

您需要在输出中设置顺序，然后需要考虑如何处理它。

您需要至少2个可运行程序（任务），以便执行者可以使用不同的线程运行它们。此外，为了获得所需的行为，您需要任务之间的某种通信方式（或者让它们生成新的子任务）。但是，我强烈建议您深入研究线程和任务。让两个线程按顺序运行一个基本相似的任务有点违背了多线程的目的——就像将任务绑定到特定线程有点违背了线程池的目的一样。谢谢Thomas。如果“让两个线程按顺序运行一个基本相似的任务违背了多线程的目的”。。。。那么Executor.newFixedThreadPool（）和.execute（runnable）方法的用途是什么？我们不只是通过不同的线程执行相同的可运行线程吗？

Executor.newFixedThreadPool（）

旨在提供一个固定的工作线程池，其中任何一个都可以交给需要执行的任务。通过

Executor.execute（Runnable）

将单个任务传递给执行器，然后执行器将该任务交给工作线程。基本思想是一个任务由一个线程执行。你知道为什么这会停留在6位吗？是的！！执行者必须被明确地停止，否则他们会继续监听新任务。您需要使用service.shutdown（）方法关闭执行器。我希望这有帮助。调用

shutdown（）

不会有帮助，因为您的所有任务都处于

状态。等待（）

结束。

private AtomicInteger number = new AtomicInteger(0);

  public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(2);

    ForTestApplication testApplication = new ForTestApplication();

    for (int i = 0; i < 100; i++) {
      executor.execute(testApplication::print);
    }

  }

  public void print () {
    System.out.println(Thread.currentThread().getName() + " : " + number.incrementAndGet());
  }

pool-1-thread-1 : 1
pool-1-thread-2 : 2
pool-1-thread-1 : 3
pool-1-thread-1 : 4
pool-1-thread-2 : 5
pool-1-thread-2 : 7
pool-1-thread-1 : 6
pool-1-thread-2 : 8
pool-1-thread-1 : 9
pool-1-thread-2 : 10