Condition Synchinzation--条件同步

实现同步有两种方式：competition(compete for a variable that two processes all want to read or updata simutaneously)和cooperation(a process want to tell another process that a result needed is avaliable)；针对competition主要通过mutual exclusion(At a given time, only one thread could access critical section)实现。

这部分讲解coorperation的实现方法--condition synchinzation

什么是条件同步

条件同步是指多个线程（或进程）在一定条件满足时才能继续执行，否则它们会进入等待状态。

举个简单的例子：想象你和朋友玩一个游戏，只有当你们俩都准备好了，游戏才能开始。如果有一方还没准备好，另一方就需要“等待”。这里的“等待”和“条件满足”就是条件同步的核心。

关键词：synchronized

生产者消费者问题

条件同步中最经典的问题就是生产消费：生产者生产-->通知消费者-->消费者消费

semaphore中讲到，可以通过控制信号量个数来实现有序性，最初资源为0，当资源为1时候，消费者才有东西消费，这就需要先让生产者生产资源。

现在可以用：boolean变量+wait()+notify()来实现

public class Dimension 
{
  private int dim = 0; 
  private boolean done_put = FALSE;

  public void synchronized put(int d) 
      { dim = d; 
        done_put = TRUE;  //标志有可用资源
         notify(); }

   public int synchronized get() { 
     if (!done_put) 
        wait(); //操作系统wait
     return dim;
     done_put = FALSE;}
}

Barrier

processes cannot proceed until otherthreads reach the barrier

Barrier 的核心作用是实现 多线程的协调与同步，确保某些关键点上的线程进度保持一致。Barrier阻拦，目的：实现有序，高优先级的要比低优先级的先执行（这几个线程执行某个区域的代码时候，不能先来的就先执行，必须要在屏障点barrier一下，然后优先级最高的先执行）

public class Barrier {
     public void synchronized pause() {
         wait(); } 
     public void synchronized resume_one(){
          notify(); } 
}

优先级barrier实现

每次放行优先级最高的线程

两部分组成：pause; resume_one

• public void synchronized pause(){ }用来暂停优先级判断和设置以及放行
  比较最高（替换）,比较次高（替换）,do wait() while(p>hightest);替换

• public void synchronied resume_one(){ }用来重开一轮

public class Barrier{
    int hightest=0;
    int next_high=0;
    public void synchronized pause(){
       int p;
       if(p=(getPriority())>hightest){
          next_high=highest;
          hightest=p;
       }
       else if(p=(getPriority())>next_high){
          next_high=p;
       }
        do wait()while(p<highest);
        hightest=next_hight
    }

    public void synchronized resume_one(){
       notifyALL()
   }
}

Bounded Counter

Bounded Counter（有界计数器） 是一种多线程编程中的同步机制，主要用于限制某些资源或操作的最大并发数。它的工作方式类似于信号量（Semaphore），但它更注重的是 计数 和 范围控制

Bounded Counter 是一个计数器，有一个固定的最大值（上界）和最小值（下界）。 它通常用于控制资源的使用量，防止超过最大限制或者减少到小于下限的情况。

给资源数划分了一个区域MIN, MAX

小于MIN，消费者不能消费，生产者可以加

大于MAX，生产者不能生产，消费者可以消费

互相notify动态控制资源个数保持在一定区间

public class BoundedCounter implements IBoundedCounter{
    long count=MIN;
    public void synchronized inc(){
       while(count==MAX) wait();
       if(count++==MIN) notifyAll();//notify 消费者来消费
    } 

    public void synchronized dec(){
       while(count==MIN) wait();
       if(count--==MAX) notifyALL();//notify 生产者生产（还没到MAX呢 你快来生产）
    }
}

• 条件判断均为等于边界；while()+wait ；if+notifyall()

• public void synchronized inc()用来增加资源，public void synchronized dec()用来消费资源

Semaphores 实现bounded area

设置三个信号量：

• privateSemaphore mutex = new Semaphore(1);控制互斥

• privateSemaphore space_avail =new Semaphore(10);控制空间

• private Semaphore item_avail =new Semaphore(0);控制item个数

其中space和item是互补的 放了一个item意味着少一个space

最开始space为10，item为0

class BoundedBuffer{
    private Vector buf=new Vector();
    private Semaphore mutex=new Semaphore(1);
    private Semaphore space=new Semaphore(10);
    private Semaphore mutex=new Semaphore(0);

//put: PP addElement(item) VV 回归(先space后item)
    public void put(int item){
       space.P();
       mutex.P();
       buf.addElement(item);
       mutex.V();
       item.V();
    }

//get: PP removeElementAt(0) VVR (先item后space)
    public int get() { 
         item_avail.P(); 
         mutex. P(); 
         int item =buf.removeElementAt(0); 
         mutex.V(); 
         space_avail.V(); 
         return item; 
       }
}