tsk4.java

package some;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class tsk4 {
 final static Lock _lk = new ReentrantLock();

 static void prt(Object a) {
 _lk.lock();
 System.out.println(a);
 _lk.unlock();
 }

 public static void main(String[] args) {
 var es = new exsr(3);

 var a = es.submit(() -> {
 try { Thread.sleep(4000); }
 catch (InterruptedException ignored) {}
 prt('a');
 });
 var b = es.submit(() -> {
 try { Thread.sleep(3000); }
 catch (InterruptedException ignored) {}
 prt('b');
 });
 var c = es.submit(() -> {
 try { Thread.sleep(2000); }
 catch (InterruptedException ignored) {}
 prt('c');
 });

 do {
 prt("" + a.isDone() + ' ' + b.isDone() + ' ' + c.isDone());
 try { Thread.sleep(250); }
 catch (InterruptedException ignored) {}
 } while (!a.isDone() || !b.isDone() || !c.isDone());

 es.sht(false);
 }

 static class exsr implements ExecutorService {
 private final int ln;
 private volatile boolean sht = false;
 private volatile boolean trm = false;
 private final ArrayList<Future<?>> tks = new ArrayList<>();
 private final Lock lk = new ReentrantLock();
 private final ArrayList<AtomicBoolean> ens = new ArrayList<>();
 private volatile boolean end = false;
 private final ArrayList<Thread> ths = new ArrayList<>();

 exsr(final int ln) { this.ln = ln; }

 private void sht(boolean a) {
 lk.lock();
 sht = true;
 for (var b : tks)
 b.cancel(a);
 trm = a;
 lk.unlock();
 }

 @Override
 public void shutdown() { sht(false); }

 @Override
 public List<Runnable> shutdownNow() {
 sht(true);
 return new ArrayList<>(0);
 }

 @Override
 public boolean isShutdown() { return sht; }

 @Override
 public boolean isTerminated() { return trm; }

 @Override
 public boolean awaitTermination(long timeout, TimeUnit unit)
 throws InterruptedException {
 if (end) throw new IllegalStateException();
 while (!end) Thread.onSpinWait();
 return false;
 }

 private void chk() {
 lk.lock();
 var a = true;
 for (var b : ens)
 a &= b.get();
 end = a;
 lk.unlock();
 }

 @Override
 public <T> Future<T> submit(Callable<T> a) {
 lk.lock();
 if (tks.size() == ln || sht) throw new IllegalStateException();

 final var bl = new AtomicBoolean(false);
 ens.add(bl);
 var c = new FutureTask<T>(() -> {
 var d = a.call();
 bl.set(true);
 chk();
 return d;
 });
 tks.add(c);

 var d = new Thread(c::run);
 ths.add(d);
 d.start();

 lk.unlock();
 return c;
 }

 @Override
 public <T> Future<T> submit(Runnable a, T b) {
 lk.lock();
 if (tks.size() == ln || sht) throw new IllegalStateException();

 final var bl = new AtomicBoolean(false);
 ens.add(bl);
 var c = new FutureTask<T>(() -> {
 a.run();
 bl.set(true);
 chk();
 }, b);
 tks.add(c);

 var d = new Thread(c::run);
 ths.add(d);
 d.start();

 lk.unlock();
 return c;
 }

 @Override
 public Future<?> submit(Runnable a) { return submit(a, null); }

 @SuppressWarnings("unchecked")
 @Override
 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> a) {
 lk.lock();
 for (var i : a) {
 var j = new FutureTask<T>(i);
 tks.add(j);
 j.run();
 }
 var b = tks.clone();
 lk.unlock();
 return (List<Future<T>>) b;
 }

 @Override
 public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> a, long b, TimeUnit c)
 { return invokeAll(a); }

 @Override
 public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
 { throw new UnsupportedOperationException(); }

 @Override
 public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
 { throw new UnsupportedOperationException(); }

 @Override
 public void execute(Runnable a) { submit(a); }
 }
}