Index: src/OFStreamObserver_kqueue.m
==================================================================
--- src/OFStreamObserver_kqueue.m
+++ src/OFStreamObserver_kqueue.m
@@ -95,38 +95,45 @@
 	[changeList addItem: &event];
 }
 
 - (BOOL)observeWithTimeout: (int)timeout
 {
+	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
 	struct timespec timespec = { timeout, 0 };
 	struct kevent eventList[EVENTLIST_SIZE];
 	int i, events;
 
 	[self _processQueue];
 
-	if ([self _processCache])
+	if ([self _processCache]) {
+		[pool release];
 		return YES;
+	}
 
 	events = kevent(kernelQueue, [changeList cArray],
 	    (int)[changeList count], eventList, EVENTLIST_SIZE,
 	    (timeout == -1 ? NULL : &timespec));
 
 	if (events == -1) {
 		switch (errno) {
 		case EINTR:
+			[pool release];
 			return NO;
 		case ENOMEM:
+			[pool release];
 			@throw [OFOutOfMemoryException exceptionWithClass: isa];
 		default:
 			assert(0);
 		}
 	}
 
 	[changeList removeNItems: [changeList count]];
 
-	if (events == 0)
+	if (events == 0) {
+		[pool release];
 		return NO;
+	}
 
 	for (i = 0; i < events; i++) {
 		if (eventList[i].ident == cancelFD[0]) {
 			char buffer;
 
@@ -136,24 +143,31 @@
 		}
 
 		if (eventList[i].flags & EV_ERROR) {
 			[delegate streamDidReceiveException:
 			    FDToStream[eventList[i].ident]];
+			[pool releaseObjects];
 			continue;
 		}
 
 		switch (eventList[i].filter) {
 		case EVFILT_READ:
 			[delegate streamIsReadyForReading:
 			    FDToStream[eventList[i].ident]];
+			[pool releaseObjects];
 			break;
 		case EVFILT_WRITE:
 			[delegate streamIsReadyForWriting:
 			    FDToStream[eventList[i].ident]];
+			[pool releaseObjects];
+			break;
 		default:
 			assert(0);
 		}
+
 	}
+
+	[pool release];
 
 	return YES;
 }
 @end

Index: src/OFStreamObserver_poll.m
==================================================================
--- src/OFStreamObserver_poll.m
+++ src/OFStreamObserver_poll.m
@@ -125,23 +125,27 @@
 	struct pollfd *FDsCArray;
 	size_t i, nFDs;
 
 	[self _processQueue];
 
-	if ([self _processCache])
+	if ([self _processCache]) {
+		[pool release];
 		return YES;
+	}
 
 	FDsCArray = [FDs cArray];
 	nFDs = [FDs count];
 
 #ifdef OPEN_MAX
 	if (nFDs > OPEN_MAX)
 		@throw [OFOutOfRangeException exceptionWithClass: isa];
 #endif
 
-	if (poll(FDsCArray, (nfds_t)nFDs, timeout) < 1)
+	if (poll(FDsCArray, (nfds_t)nFDs, timeout) < 1) {
+		[pool release];
 		return NO;
+	}
 
 	for (i = 0; i < nFDs; i++) {
 		if (FDsCArray[i].revents & POLLIN) {
 			if (FDsCArray[i].fd == cancelFD[0]) {
 				char buffer;

Index: src/OFStreamObserver_select.m
==================================================================
--- src/OFStreamObserver_select.m
+++ src/OFStreamObserver_select.m
@@ -78,12 +78,14 @@
 	struct timeval time;
 	size_t i, count;
 
 	[self _processQueue];
 
-	if ([self _processCache])
+	if ([self _processCache]) {
+		[pool release];
 		return YES;
+	}
 
 #ifdef FD_COPY
 	FD_COPY(&readFDs, &readFDs_);
 	FD_COPY(&writeFDs, &writeFDs_);
 	FD_COPY(&exceptFDs, &exceptFDs_);
@@ -95,12 +97,14 @@
 
 	time.tv_sec = timeout / 1000;
 	time.tv_usec = (timeout % 1000) * 1000;
 
 	if (select((int)maxFD + 1, &readFDs_, &writeFDs_, &exceptFDs_,
-	    (timeout != -1 ? &time : NULL)) < 1)
+	    (timeout != -1 ? &time : NULL)) < 1) {
+		[pool release];
 		return NO;
+	}
 
 	if (FD_ISSET(cancelFD[0], &readFDs_)) {
 		char buffer;
 #ifndef _WIN32
 		assert(read(cancelFD[0], &buffer, 1) > 0);