همگام سازی (synchronizing) داده با نخ (Thread) ها در جاوا و کاتلین

public class StudentAccount{

  private static Account account = new Account();

      public static void main(String[] args) {

          ExecutorService service = Executors.newCachedThreadPool();

          for (int i=0; i<100; i++){
              service.execute(new IncrementScoreByOne());
          }

          service.shutdown();

          while (!service.isTerminated());

          System.out.println("student score is " + account.getScore());
      }


      private static class IncrementScoreByOne implements Runnable{
          @Override
          public void run() {
              account.updateScore(1);
          }
      }

      private static class Account{
          private Integer score = 0;

          public void updateScore(int v){
              int newScore = score + v;
              try {
                  Thread.sleep(5);
              }catch (InterruptedException e){
                  throw new RuntimeException(e);
              }

              score = newScore;
          }

          public int getScore() {
              return score;
          }
      }
  }
        

private val account = Account()

fun main() {
    val service = Executors.newCachedThreadPool()

    for (i in 1..100) {
        service.execute(IncrementScoreByOne())
    }

    service.shutdown()

    while (!service.isTerminated);

    println("The student score is " + account.score)
}

private class IncrementScoreByOne : Runnable {
    override fun run() {
        account.updateScore(1)
    }
}

private class Account {

    var score: Int = 0
        private set

    fun updateScore(v: Int) {

        val newScore = score + v

        try {
            Thread.sleep(5)
        } catch (e: InterruptedException) {
            throw RuntimeException(e)
        }

        score = newScore

    }
}
        

public static void main(String[] args){
    Permission permission = new Permission();

    ExecutorService service = Executors.newFixedThreadPool(3);
    service.execute(new TaskA(permission));
    service.execute(new TaskB(permission));
    service.execute(new UserInputPermissionTask(permission));

    service.shutdown();
}

private static class Permission {
    private volatile boolean granted;
}

private static class TaskA implements Runnable {
    private Permission permission;

    public TaskA(Permission permission) {
        this.permission = permission;
    }

    @Override
    public void run() {
        while (!permission.granted) ;

        System.out.println("A message from TaskA");
    }
}

private static class TaskB implements Runnable{
    private Permission permission;

    public TaskB(Permission permission){
        this.permission = permission;
    }

    @Override
    public void run() {
        while (!permission.granted);

        System.out.println("A message from TaskB");
    }
}

private static class UserInputPermissionTask implements Runnable{

    private Permission permission;

    public UserInputPermissionTask(Permission permission){
        this.permission = permission;
    }


    @Override
    public void run() {
        Scanner input = new Scanner(System.in);

        while (true) {
            System.out.println("Ask permission: Do u wanna print message?(yes/no)");
            String userInput = input.next();
            if (userInput.equalsIgnoreCase("y") || userInput.equalsIgnoreCase("yes")) {
                permission.granted = true;
                System.out.println("Permission Granted!");
                break;
            }
            else {
                System.out.println("Permission Denied!");
            }
        }
    }
}
        

fun main() {
    val permission = Permission()

    val service = Executors.newFixedThreadPool(3)
    service.execute(TaskA(permission))
    service.execute(TaskB(permission))
    service.execute(UserInputPermissionTask(permission))

    service.shutdown()
}


private class Permission {
    @Volatile
    var granted = false
}

private class TaskA(private val permission: Permission) : Runnable {
    override fun run() {
        while (!permission.granted);

        println("A message from TaskA")
    }
}

private class TaskB(private val permission: Permission) : Runnable {
    override fun run() {
        while (!permission.granted);

        println("A message from TaskB")
    }
}

private class UserInputPermissionTask(private val permission: Permission) : Runnable {
    override fun run() {
        val input = Scanner(System.`in`)

        while (true) {
            println("Ask permission: Do u wanna print message?(yes/no)")
            val userInput = input.next()
            if (userInput.equals("y", ignoreCase = true) || userInput.equals("yes", ignoreCase = true)) {
                permission.granted = true
                println("Permission Granted!")
                break
            } else {
                println("Permission Denied!")
            }
        }
    }
}
        

public class StudentAccountVolatile {
    private static final Account account = new Account();

    public static void main(String[] args) {

        ExecutorService service = Executors.newCachedThreadPool();

        while (account.getScore() != 100)
            service.execute(new IncrementScoreByOne());

        service.shutdown();

        while (!service.isTerminated()) ;

        System.out.println(account.getScore());
    }

    private static class IncrementScoreByOne implements Runnable{

        @Override
        public void run() {
            if (account.getScore() != 100)
                account.updateScore(1);
        }
    }

    private static class Account {
        private volatile Integer score = 0;

        public void updateScore(int v) {
            int newScore = score + v;
            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            score = newScore;
        }

        public int getScore() {
            return score;
        }
    }
}
        

private val account = Account()

fun main() {
    val service = Executors.newCachedThreadPool()

    while (account.score != 100) service.execute(IncrementScoreByOne())

    service.shutdown()

    while (!service.isTerminated);

    println(account.score)
}

private class IncrementScoreByOne : Runnable {
    override fun run() {
        if (account.score != 100) account.updateScore(1)
    }
}

private class Account {
    @Volatile
    var score: Int = 0
        private set

    fun updateScore(v: Int) {
        val newScore = score + v
        try {
            Thread.sleep(5)
        } catch (e: InterruptedException) {
            throw RuntimeException(e)
        }

        score = newScore
    }
}
        

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ConsumerProducerDemo {

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

        ConsumerProducer cp = new ConsumerProducer();

            service.execute(() -> {
                while (true)
                    cp.consume();
            });


            service.execute(() -> {
                while (true)
                    cp.produce();
            });

            service.shutdown();

    }

    private static class ConsumerProducer{
        private int data;


        public synchronized void consume(){
            try {

                while (data == 0) {
                    wait();
                }
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            System.out.println("Consuming " + data);
            data = 0;
            notify();
        }

        public synchronized void produce(){

            try {
                while (data != 0) {
                    wait();
                }

                Thread.sleep(2000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            data = (int) (1 + (Math.random() * 126));
            System.out.println("Producing " + data);
            notify();
        }
    }
}       
        

fun main(){
    val service = Executors.newFixedThreadPool(2)
    val cp = ConsumerProducer()
    service.execute(Runnable {
        while (true) cp.consume()
    })
    service.execute(Runnable {
        while (true) cp.produce()
    })
    service.shutdown()
}

@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
private class ConsumerProducer{
    private var data = 0

    @Synchronized
    fun consume() {

        try {
            while (data == 0) {
                (this as Object).wait()
            }
            Thread.sleep(1000)
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }
        
        println("Consuming $data")
        data = 0
        (this as Object).notify()
    }

    @Synchronized
    fun produce() {
        try {
            while (data != 0) {
                (this as Object).wait()
            }
            Thread.sleep(2000)
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }
        data = (1 + (Math.random() * 126)).toInt()
        println("Producing $data")
        (this as Object).notify()
    }

}
        

private static class Account{
  private Integer score = 0;

  private Lock lock = new ReentrantLock();

  public void updateScore(int v){
      lock.lock();
      try {
          int newScore = score + v;
          Thread.sleep(5);
          score = newScore;
      }catch (InterruptedException e){
          throw new RuntimeException(e);
      }finally{
        lock.unlock();
      }
  }
  public int getScore() {
      return score;
  }
}
        

private class Account {
  val lock: Lock = ReentrantLock()
  var score: Int = 0
      private set

  fun updateScore(v: Int) {
      lock.lock()
      try {
          val newScore = score + n
          Thread.sleep(5)
          score = newScore
      } catch (e: InterruptedException) {
          throw RuntimeException(e)
      }finally{
          lock.unlock()
      }
  }
}
        

public class ConsumerProducerReentrantLockDemo {

    private static final Buffer buffer = new Buffer();

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new ProducerTask());
        service.execute(new ConsumerTask());

        service.shutdown();
    }

    private static class ProducerTask implements Runnable{
        @Override
        public void run() {
            while (true){
                int value = (int)(Math.random() * 256);
                System.out.println("Producer writes " + value);
                buffer.write(value);
                try {
                    Thread.sleep((long)(Math.random() * 10000));
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }

        }
    }

    private static class ConsumerTask implements Runnable{
        @Override
        public void run() {
            while (true){
                int value = buffer.read();
                System.out.println("\t\t\tConsumer reads " + value);
                try {
                    Thread.sleep((int)(Math.random() * 10000));
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }

    private static class Buffer{
        private static final int CAPACITY = 1;
        private final Queue<Integer> queue = new LinkedList<>();

        private final Lock lock = new ReentrantLock();

        private final Condition writeCondition = lock.newCondition();
        private final Condition readCondition = lock.newCondition();

        public void write(int value){
            lock.lock();

            try{
                while (isFull()) {
                    System.out.println("Wait for reading buffer");
                    writeCondition.await();
                }

                queue.offer(value);
                readCondition.signal();
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }


        public int read(){
            int value = 0;
            lock.lock();
            try {
                while (isEmpty()){
                    System.out.println("\t\t\tWait for writing buffer");
                    readCondition.await();
                }

                value = queue.remove();
                writeCondition.signal();

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

            return value;
        }

        private boolean isEmpty(){
            return queue.isEmpty();
        }

        private boolean isFull(){
            return queue.size == CAPACITY;
        }
    }
}

        

private val buffer = Buffer()

fun main() {
    val service = Executors.newFixedThreadPool(2)
    service.execute(Producer())
    service.execute(Consumer())

    service.shutdown()
}

private class ProducerTask : Runnable {
    override fun run() {
        while (true) {
            val value = (Math.random() * 256).toInt()
            println("Producer writes $value")
            buffer.write(value)
            try {
                Thread.sleep((Math.random() * 10000).toLong())
            } catch (e: InterruptedException) {
                throw RuntimeException(e)
            }
        }
    }
}

private class ConsumerTask : Runnable {
    override fun run() {
        while (true) {

            val value = buffer.read()
            println("\t\t\tConsumer reads $value")

            try {
                Thread.sleep((Math.random() * 10000).toInt().toLong())
            } catch (e: InterruptedException) {
                throw RuntimeException(e)
            }

        }
    }
}

private class Buffer {
    private val queue: Queue<Int> = LinkedList()

    private val lock: Lock = ReentrantLock()

    private val writeCondition: Condition = lock.newCondition()
    private val readCondition: Condition = lock.newCondition()

    private val isEmpty get() = queue.isEmpty()
    private val isFull get() = queue.size == CAPACITY

    fun write(value: Int) {
        lock.lock()

        try {
            while (isFull) {
                println("Wait for reading buffer")
                writeCondition.await()
            }

            queue.offer(value)
            readCondition.signal()
        } catch (e: InterruptedException) {
            e.printStackTrace()
        } finally {
            lock.unlock()
        }
    }


    fun read(): Int {
        var value = 0
        lock.lock()
        try {
            while (isEmpty) {
                println("\t\t\tWait for writing buffer")
                readCondition.await()
            }

            value = queue.remove()!!
            writeCondition.signal()
        } catch (e: InterruptedException) {
            e.printStackTrace()
        } finally {
            lock.unlock()
        }

        return value
    }

    companion object {
        private const val CAPACITY = 1
    }
}
        

private static class Account{
  private int score = 0;

  private final Semaphore semaphore = new Semaphore(1);

  public void updateScore(int v){
      
      try {

        semaphore.acquire();
        int newScore = score + v;
        Thread.sleep(5);
        score = newScore;

      }catch (InterruptedException e){
          throw new RuntimeException(e);
      }finally{
        semaphore.release();
      }
  }
  public int getScore() {
      return score;
  }
}
        

private class Account {
  val semaphore = Semaphore(1)
  var score: Int = 0
      private set

  fun updateScore(v: Int) {
      
      try {
          semaphore.acquire()
          val newScore = score + n
          Thread.sleep(5)
          score = newScore
      } catch (e: InterruptedException) {
          throw RuntimeException(e)
      }finally{
          semaphore.release()
      }
  }
}        
        

ExecutorService service = Executors.newFixedThreadPool(2);

Object object = new Object();
Object object1 = new Object();


service.execute(() -> {
  synchronized (object) {

      System.out.println("From object");

      try {
          Thread.sleep(200);
      } catch (InterruptedException e) {

      }

      synchronized (object1) {
          System.out.println("Causes dead lock");
      }
  }
});


service.execute(() -> {

  synchronized (object1) {
      System.out.println("From object1");

      synchronized (object) {
          System.out.println("Causes dead lock");
      }
  }
});

service.shutdown();
        

fun main(){
    val service = Executors.newFixedThreadPool(2)
    
    val any = Any()
    val any1 = Any()


    service.execute(Runnable {
        synchronized(any) {
            println("From object")
            try {
                Thread.sleep(200)
            } catch (e: InterruptedException) {
            }
            synchronized(any1) {
                println("Causes dead lock")
            }
        }
    })


    service.execute(Runnable {
        synchronized(any1) {
            println("From object1")
            synchronized(any) {
                println("Causes dead lock")
            }
        }
    })

    service.shutdown()

}
        

public class ConsumerProducerDemo {

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

        Producer producer = new Producer();
        Consumer consumer = new Consumer();

        //ConsumerProducer cp = new ConsumerProducer();

            service.execute(() -> {
                while (true)
                    consumer.consume(producer);
            });


            service.execute(() -> {
                while (true)
                    producer.produce();
            });

            service.shutdown();

    }


    private static class Producer{
        private int data ;

        public synchronized void produce(){
            try {
                while (data != 0)
                    wait();
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            data = (int) (1 + (Math.random() * 126));
            System.out.println("Producing " + data);
            notifyAll();

        }

        public void resetData(){
            data = 0;
        }
    }

    private static class Consumer{

        public synchronized void consume(Producer producer){
            try {

                while (producer.data == 0) {
                    wait();
                }
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }

            System.out.println("Consuming " + producer.data);
            producer.resetData();
            notifyAll();
        }
    }

}
        

fun main(){

    val service = Executors.newFixedThreadPool(2)

    val producer = Producer()
    val consumer = Consummer()

    service.execute({
        while (true) consumer.consume(producer)
    })
    service.execute({
        while (true) producer.produce()
    })
    service.shutdown()

}

private class Producer {
    private var data = 0

    @Synchronized
    fun produce() {
        try {
            while (data != 0) (this as Object).wait()
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }
        data = (1 + (Math.random() * 126)).toInt()
        println("Producing " + data)
        (this as Object).notifyAll()
    }

    fun resetData() {
        data = 0
    }
}

private class Consumer {
    @Synchronized
    fun consume(producer: Producer) {
        try {
            while (producer.data == 0) {
                (this as Object).wait()
            }
            Thread.sleep(1000)
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }
        println("Consuming " + producer.data)
        producer.resetData()
        (this as Object).notifyAll()
    }
}