src/java.base/macosx/classes/sun/nio/ch/KQueuePoller.java

*** 23,10 ***
--- 23,12 ---
   * questions.
   */
  package sun.nio.ch;
  
  import java.io.IOException;
+ import java.lang.ref.Cleaner.Cleanable;
+ import jdk.internal.ref.CleanerFactory;
  import static sun.nio.ch.KQueue.*;
  
  /**
   * Poller implementation based on the kqueue facility.
   */

*** 34,15 ***
      private final int kqfd;
      private final int filter;
      private final int maxEvents;
      private final long address;
  
      KQueuePoller(boolean subPoller, boolean read) throws IOException {
!         this.kqfd = KQueue.create();
          this.filter = (read) ? EVFILT_READ : EVFILT_WRITE;
!         this.maxEvents = (subPoller) ? 64 : 512;
!         this.address = KQueue.allocatePollArray(maxEvents);
      }
  
      @Override
      int fdVal() {
          return kqfd;
--- 36,79 ---
      private final int kqfd;
      private final int filter;
      private final int maxEvents;
      private final long address;
  
+     // file descriptors used for wakeup during shutdown
+     private final int fd0;
+     private final int fd1;
+ 
+     // close action, and cleaner if this is subpoller
+     private final Runnable closer;
+     private final Cleanable cleaner;
+ 
      KQueuePoller(boolean subPoller, boolean read) throws IOException {
!         int maxEvents = (subPoller) ? 16 : 64;
+ 
+         int kqfd = -1;
+         long address = 0L;
+         int fd0 = -1;
+         int fd1 = -1;
+         try {
+             kqfd = KQueue.create();
+             address = KQueue.allocatePollArray(maxEvents);
+ 
+             // register one of the pipe with kqueue to allow for wakeup
+             long fds =  IOUtil.makePipe(false);
+             fd0 = (int) (fds >>> 32);
+             fd1 = (int) fds;
+             KQueue.register(kqfd, fd0, EVFILT_READ, EV_ADD);
+         } catch (Throwable e) {
+             if (kqfd >= 0) FileDispatcherImpl.closeIntFD(kqfd);
+             if (address != 0L) KQueue.freePollArray(address);
+             if (fd0 >= 0) FileDispatcherImpl.closeIntFD(fd0);
+             if (fd1 >= 0) FileDispatcherImpl.closeIntFD(fd1);
+             throw e;
+         }
+ 
+         this.kqfd = kqfd;
          this.filter = (read) ? EVFILT_READ : EVFILT_WRITE;
!         this.maxEvents = maxEvents;
!         this.address = address;
+         this.fd0 = fd0;
+         this.fd1 = fd1;
+ 
+         // create action to close kqueue, register cleaner if this is a subpoller
+         this.closer = closer(kqfd, address, fd0, fd1);
+         if (subPoller) {
+             this.cleaner = CleanerFactory.cleaner().register(this, closer);
+         } else {
+             this.cleaner = null;
+         }
+     }
+ 
+     /**
+      * Returns an action to close the kqueue and release other resources.
+      */
+     private static Runnable closer(int kqfd, long address, int fd0, int fd1) {
+         return () -> {
+             try {
+                 FileDispatcherImpl.closeIntFD(kqfd);
+                 KQueue.freePollArray(address);
+                 FileDispatcherImpl.closeIntFD(fd0);
+                 FileDispatcherImpl.closeIntFD(fd1);
+             } catch (IOException _) { }
+         };
+     }
+ 
+     @Override
+     void close() {
+         if (cleaner != null) {
+             cleaner.clean();
+         } else {
+             closer.run();
+         }
      }
  
      @Override
      int fdVal() {
          return kqfd;

*** 61,18 ***
          if (!polled) {
              KQueue.register(kqfd, fdVal, filter, EV_DELETE);
          }
      }
  
      @Override
      int poll(int timeout) throws IOException {
          int n = KQueue.poll(kqfd, address, maxEvents, timeout);
          int i = 0;
          while (i < n) {
              long keventAddress = KQueue.getEvent(address, i);
              int fdVal = KQueue.getDescriptor(keventAddress);
!             polled(fdVal);
              i++;
          }
!         return n;
      }
  }
--- 127,27 ---
          if (!polled) {
              KQueue.register(kqfd, fdVal, filter, EV_DELETE);
          }
      }
  
+     @Override
+     void wakeupPoller() throws IOException {
+         IOUtil.write1(fd1, (byte)0);
+     }
+ 
      @Override
      int poll(int timeout) throws IOException {
          int n = KQueue.poll(kqfd, address, maxEvents, timeout);
+         int polled = 0;
          int i = 0;
          while (i < n) {
              long keventAddress = KQueue.getEvent(address, i);
              int fdVal = KQueue.getDescriptor(keventAddress);
!             if (fdVal != fd0) {
+                 polled(fdVal);
+                 polled++;
+             }
              i++;
          }
!         return polled;
      }
  }