Reactive Web - Servlet & Async, Non-blocking I/O

Servlet 2.2
JSP 1.1
Servlet 2.3
JSP 1.2
JSTL 1.0
Servlet 2.4
JSP 2.0
JSTL 1.1
Servlet 2.5
JSP 2.1
EL 2.1
JSTL 1.2
Servlet 3.0
JSP 2.2
EL 2.2
JSTL 1.2
Servlet 3.1
JSP 2.3
EL 3.0
JSTL 1.2

Ý
GET /hello?name=arwan HTTP/1.1
<html> … </html>
Tomcat
Undertow
Jetty
HttpServletRequest 
HttpServletResponse
@WebServlet(urlPatterns = {"/hello"})
class HelloServlet extends HttpServlet { … }

Ý
Ý
Ý
Ý{
“content”: “…”
}

@WebServlet("/notification/stream") 
public class NotificationStreamServlet extends HttpServlet { 
final static Log log = LogFactory.getLog(NotificationStreamServlet.class);
 
@Override 
protected void service(HttpServletRequest request, HttpServletResponse response) throws Exception {
log.info("in notification/stream"); 
 
response.setCharacterEncoding("utf-8"); 
response.setContentType("text/event-stream"); 
 
try { 
NotificationStream notificationStream = new NotificationStream(obtainUsername(request)); 
Iterator<Notification> notifies = notificationStream.feedNotifies(); 
 
while (notifies.hasNext()) { 
Notification notification = notifies.next(); 
 
ServletOutputStream outputStream = response.getOutputStream(); 
outputStream.write(("event: " + notification.getEvent() + "n").getBytes()); 
outputStream.write(("data: " + notification.getData() + "nn").getBytes()); 
outputStream.flush(); 
} 
} catch (Exception error) { 
log.error("error notification/stream : " + error.getMessage()); 
} 
 
log.info("out notification/stream”);
} 
 
String obtainUsername(HttpServletRequest request) { 
return request.getParameter("username"); 
} 
}

class FeedService { 
 
final String FEED_NOTIFY_URL = "http://localhost:9000/user/%s/feed"; 
final ObjectMapper MAPPER = new ObjectMapper(); 
 
FeedNotify getFeedNotify(String username) { 
try { 
URL url = new URL(String.format(FEED_NOTIFY_URL, username)); 
 
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection(); 
urlConnection.setRequestMethod("GET"); 
urlConnection.setRequestProperty("Accept", "application/json"); 
urlConnection.setConnectTimeout(3000); 
urlConnection.setReadTimeout(3000); 
 
return MAPPER.readValue(urlConnection.getInputStream(), FeedNotify.class); 
} catch (IOException error) { 
throw new ServiceOperationException(error); 
} 
} 
 
}
// FeedService ,  
FeedService feedService = new FeedService(); 
 
String username = "guest"; 
Iterator<Notification> feedNotifies = Stream.generate(() -> feedService.getFeedNotify(username)) 
.map(Notification::of) 
.iterator(); 
 
 
while (feedNotifies.hasNext()) { 
Notification next = feedNotifies.next(); 
 
System.out.println(next); 
}

@WebServlet(urlPatterns = "/async", asyncSupported = true) 
public class SimpleAsyncServlet extends HttpServlet { 
protected void service(HttpServletRequest request, HttpServletResponse response) throws Exception {
 
//  
AsyncContext asyncContext = request.startAsync(request, response); 
//  
asyncContext.setTimeout(60 * 1000);
 
//  
asyncContext.addListener(new AsyncListener() { 
//
public void onComplete(AsyncEvent event) throws IOException { … }
// AsyncContext.setTimeout()  
public void onTimeout(AsyncEvent event) throws IOException { … } 
//
public void onError(AsyncEvent event) throws IOException { … }
//  
public void onStartAsync(AsyncEvent event) throws IOException { … } 
}); 
//  
asyncContext.start(new Runnable() { 
public void run() { 
//  
asyncContext.complete(); //  
} 
}); 
} 
}

@WebServlet(urlPatterns = "/notification/stream/async", asyncSupported = true) 
public class AsyncNotificationStreamServlet extends HttpServlet { 
 
@Override 
protected void service(HttpServletRequest request, HttpServletResponse response) throws Exception { 
log.info("in notification/stream/async"); 
 
 
AsyncContext asyncContext = request.startAsync(); 
asyncContext.setTimeout(30000); 
public void onComplete(AsyncEvent event) throws IOException { … } 
public void onTimeout(AsyncEvent event) throws IOException { … } 
public void onError(AsyncEvent event) throws IOException { … } 
public void onStartAsync(AsyncEvent event) throws IOException { … } 
}); 
asyncContext.start(() -> { 
try { 
Iterator<Notification> notifies = notificationStream.feedNotifies(); 
 
while (notifies.hasNext() && !asyncDone.get()) { 
 
ServletOutputStream outputStream = asyncContext.getResponse().getOutputStream(); 
} 
log.error("error notification/stream/async - " + error.getMessage()); 
} finally { 
asyncContext.complete(); 
} 
}); 
 
log.info("out notification/stream/async"); 
}
}

class NotifyApi { 
 
static Log LOG = LogFactory.getLog(NotifyApi.class); 
 
final String FRIEND_NOTIFY_URL = "http://localhost:9000/user/%s/friend-recommendation"; 
 
final ObjectMapper MAPPER = new ObjectMapper(); 
 
FeedNotify getFeedNotify(String username) { 
LOG.info("FeedNotify ."); 
 
try { 
URL url = new URL(String.format(FEED_NOTIFY_URL, username)); 
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection(); 
FeedNotify feedNotify = MAPPER.readValue(urlConnection.getInputStream(), FeedNotify.class); 
 
 
return feedNotify; 
} 
} 
 
FriendRecommendationNotify getFriendRecommendationNotify(String username) { 
LOG.info("FriendRecommendationNotify ."); 
try { 
URL url = new URL(String.format(FRIEND_NOTIFY_URL, username)); 
//  
 
LOG.info("FriendRecommendationNotify ."); 
 
return notify; 
} 
} 
}

public class SynchronousCallExample { 
 
public static void main(String[] args) { 
 
 
NotifyApi notifyApi = new NotifyApi(); 
 
 
FeedNotify feedNotify = notifyApi.getFeedNotify(username); 
 
// feedNotify  
 
 
FriendRecommendationNotify friendNotify = notifyApi.getFriendRecommendationNotify(username); 
 
// friendNotify  
 
} 
 
}

FeedNotify
getFeedNotify(username)
HTTP /
FriendRecommendationNotify
getFriendRecommendationNotify(username)
HTTP /

public class AsynchronousCallByThreadExample { 
 
static Log LOG = LogFactory.getLog(AsynchronousCallByThreadExample.class); 
 
public static void main(String[] args) throws Exception { 
 
 
Thread feedThread = new Thread(new Runnable() { 
 
@Override 
 
LOG.info(feedNotify); 
 
} 
 
}); 
feedThread.start(); 
 
 
Thread friendThread = new Thread(() -> { 
 
LOG.info(friendNotify); 
 
}); 
friendThread.start(); 
 
} 
 
}

<<Interface>>
Executor
<<Interface>>
ExecutorService
<<Interface>>
ScheduledExecutorService
ForkJoinPool
AbstractExecutorService
ThreadPoolExecutor
ScheduledThreadPoolExecutor
ExecutorService executorService = Executors.newFixedThreadPool(4);

public class AsynchronousCallByExecutorExample { 
 
static Log LOG = LogFactory.getLog(AsynchronousCallByExecutorExample.class); 
 
public static void main(String[] args) throws Exception { 
 
 
 
Executor executor = Executors.newFixedThreadPool(4); 
 
 
executor.execute(new Runnable() {
 
@Override 
LOG.info(feedNotify); 
}
 
}); 
 
executor.execute(() -> {
 
LOG.info(friendNotify);
 
}); 
 
} 
 
}

ExecutorService executorService = Executors.newCachedThreadPool(); 
 
Future<String> future = executorService.submit(new Callable<String>() {
 
@Override 
public String call() throws Exception { 
 
//  
 
return "asynchronous call"; 
}
 
}); 
 
String result = future.get(1, TimeUnit.SECONDS);

 
 
 
final ExecutorService executorService = Executors.newCachedThreadPool(); 
final ObjectMapper objectMapper = new ObjectMapper(); 
 
FeedNotify getFeedNotify(String username) { … } 
 
Future<FeedNotify> getFeedNotifyForFuture(String username) {
 
return executorService.submit(new Callable<FeedNotify>() {
 
@Override 
public FeedNotify call() throws Exception { 
return getFeedNotify(username); 
}
 
}); 
} 
 
FriendRecommendationNotify getFriendRecommendationNotify(String username) { … } 
 
Future<FriendRecommendationNotify> getFriendRecommendationNotifyForFuture(String username) { 
return executorService.submit(() -> getFriendRecommendationNotify(username)); 
} 
 
}

 
 
Future<FeedNotify> feedFuture = notifyApi.getFeedNotifyForFuture(username); 
Future<FriendRecommendationNotify> friendFuture = notifyApi.getFriendRecommendationNotifyForFuture(username); 
 
for (;;) { 
if (feedFuture.isDone()) { 
FeedNotify feedNotify = feedFuture.get(); 
 
// feedNotify  
 
break; 
} 
 
//  
// feedFuture.cancel(true);
 
Thread.sleep(100); 
} 
 
 
FriendRecommendationNotify friendNotify = friendFuture.get(1, TimeUnit.SECONDS); 
 
// friendNotify

HTTP /
feedFuture
HTTP /
friendFuture
feedFuture.isDone() or cancel()
feedFuture.get()
friendFuture.get()

String username = "elton"; 
 
 
Future<User> userFuture = notifyApi.getUserForFuture(username); 
for (;;) { 
if (userFuture.isDone()) { 
User user = userFuture.get(); 
 
FeedNotify feedNotify = notifyApi.getFeedNotifyForFuture(user)
.get(1, TimeUnit.SECONDS); 
 
//  
 
break; 
} 
 
LOG.info("User ."); 
Thread.sleep(100); 
}

String username = "guest";
notifyApi.getFeedNotify(username, new CompletionHandler<FeedNotify>() { 
 
@Override 
public void onSuccess(FeedNotify result) { 
//  
} 
 
@Override 
public void onFailure(Throwable ex) { 
//  
}
 
});

//  
interface CompletionHandler<R> extends SuccessCallback<R>, FailureCallback {
}
//  
interface SuccessCallback<R> {
 
void onSuccess(R result);
 
}
//  
interface FailureCallback {
 
void onFailure(Throwable ex);
 
}
 
}

 
 
 
 
 
void getFeedNotify(String username, CompletionHandler<FeedNotify> completionHandler) { 
executorService.execute(new Runnable() {
 
@Override 
try { 
completionHandler.onSuccess(getFeedNotify(username)); 
completionHandler.onFailure(error); 
} 
}
 
}); 
} 
 
 
void getFriendRecommendationNotify(String username, CompletionHandler<FriendRecommendationNotify> handler) { … } 
 
}

 
 
notifyApi.getFeedNotify(username, new CompletionHandler<FeedNotify>() { 
 
@Override 
public void onSuccess(FeedNotify result) { 
//  
} 
 
@Override 
//  
}
 
}); 
 
 
notifyApi.getFriendRecommendationNotify(username, new CompletionHandler<FriendRecommendationNotify>() {
 
@Override 
public void onSuccess(FriendRecommendationNotify result) { 
}
 
@Override 
}
 
});

execute callback
HTTP /
execute callback
HTTP /

String username = "elton"; 
 
 
notifyApi.getUser(username, new NotifyApi.CompletionHandler<User>() { 
 
@Override 
public void onSuccess(User user) { 
 
notifyApi.getFeedNotify(user, new NotifyApi.CompletionHandler<FeedNotify>() { 
 
@Override 
public void onSuccess(FeedNotify feedNotify) { 
//  
} 
 
@Override 
public void onFailure(Throwable error) { 
//  
} 
 
}); 
 
} 
 
@Override 
public void onFailure(Throwable error) { 
//  
} 
 
});

CompletableFuture.supplyAsync(() -> { 
 
//  
 
return "async task"; 
}).thenApply(result -> { 
 
//  
 
return result.length(); 
}).exceptionally(error -> { 
 
//  
 
return Integer.MIN_VALUE; 
}).thenAccept(length -> { 
 
//  
 
LOG.info("Length : " + length); 
});

 
 
 
 
 
CompletableFuture<FeedNotify> getFeedNotifyForCF(String username) {
return CompletableFuture.supplyAsync(new Supplier<FeedNotify>() {
 
@Override 
public FeedNotify get() { 
return getFeedNotify(username); 
}
 
}, executorService); 
} 
 
 
CompletableFuture<FriendRecommendationNotify> getFriendRecommendationNotifyForCF(String username) { 
return CompletableFuture.supplyAsync(() -> getFriendRecommendationNotify(username), executorService); 
} 
 
}

 
 
notifyApi.getFeedNotifyForCF(username).thenAccept(feedNotify -> { 
// feedNotify  
}); 
 
notifyApi.getFriendRecommendationNotifyForCF(username).thenAccept(friendNotify -> { 
// friendNotify  
}); 
 
 
// 2  
notifyApi.getUserForCF(username) 
.thenCompose(notifyApi::getFeedNotifyForCF) 
.thenAccept(notifications -> { 
//  
});

class NotificationStreamObservable { 
 
ExecutorService executorService = Executors.newFixedThreadPool(1); 
Future<?> future = new FutureTask<>(() -> {}, null); 
 
 
String username; 
List<NotificationStreamObserver> observers = new CopyOnWriteArrayList<>(); 
 
NotificationStreamObservable(String username) { 
this.username = username; 
} 
 
void register(NotificationStreamObserver observer) { 
observers.add(observer); 
} 
 
void unregister(NotificationStreamObserver observer) { 
observers.remove(observer); 
} 
 
void subscribe() { 
future = executorService.submit(() -> { 
boolean running = true; 
while (running) { 
Notification feedNotify = Notification.of(notifyApi.getFeedNotify(username)); 
observers.forEach(observer -> observer.onNotification(feedNotify));
//  
} 
}); 
} 
 
void unsubscribe() { 
future.cancel(true); 
observers.clear(); 
} 
}

interface NotificationStreamObserver { 
 
void onNotification(Notification notification); 
 
}
 
 
NotificationStreamObservable observable = new NotificationStreamObservable(username); 
observable.register(notification -> { 
 
//  
 
}); 
observable.subscribe(); 
 
 
// ,  
// observable.unsubscribe();

@WebServlet(urlPatterns = "/notification/stream/async", asyncSupported = true) 
public class AsyncNotificationStreamServlet extends HttpServlet { 
@Override 
log.info("in notification/stream/async"); 
 
 
AtomicBoolean asyncDone = new AtomicBoolean(false); 
 
AsyncContext asyncContext = request.startAsync(); 
asyncContext.setTimeout((new Random().nextInt(5) + 5) * 1000); 
 
@Override 
public void onComplete(AsyncEvent event) throws IOException { } 
 
@Override 
public void onTimeout(AsyncEvent event) throws IOException { } 
 
@Override 
public void onError(AsyncEvent event) throws IOException { } 
 
@Override 
public void onStartAsync(AsyncEvent event) throws IOException { } 
 
});
 
asyncContext.start(() -> { 
//
 
}); 
 
log.info("out notification/stream/async"); 
}
}

public class NotificationStreamObservable extends Observable { 
 
final static ExecutorService executorService = Executors.newCachedThreadPool(); 
 
Iterator<Notification> feedNotifies; 
Future<?> feedFuture; 
 
public NotificationStreamObservable(NotificationStream stream) { 
this.feedNotifies = Objects.requireNonNull(stream.feedNotifies()); 
} 
 
public void subscribe() { 
feedFuture = executorService.submit(() -> { 
if (countObservers() > 0) { 
try { 
Notification notification = feedNotifies.next(); 
 
setChanged(); 
notifyObservers(notification); 
running = false; 
 
setChanged(); 
notifyObservers(error); 
} 
} 
if (Thread.interrupted()) { 
running = false; 
} 
Thread.yield(); 
} 
}); 
} 
 
public void unsubscribe() { 
feedFuture.cancel(true); 
deleteObservers(); 
}
}

class NotificationStreamObserver implements Observer, AsyncListener { 
 
final AsyncContext asyncContext; 
 
public NotificationStreamObserver(AsyncContext asyncContext) { 
this.asyncContext = Objects.requireNonNull(asyncContext); 
} 
 
@Override 
public void update(Observable observable, Object event) { 
if (event instanceof Notification) { 
handler((Notification) event); 
} 
 
//  
if (event instanceof Throwable) { 
handlerError(observable, (Throwable) event); 
} 
} 
 
@Override 
public void onComplete(AsyncEvent event) throws IOException { 
log.info("complete notification/stream/async-observer"); 
} 
 
@Override 
public void onTimeout(AsyncEvent event) throws IOException { 
handlerError(new TimeoutException("timeout")); 
} 
 
@Override 
public void onError(AsyncEvent event) throws IOException { 
handlerError(event.getThrowable()); 
} 
 
@Override 
public void onStartAsync(AsyncEvent event) throws IOException { } 
// handle, handleError
}

@WebServlet(urlPatterns = "/notification/stream/observer", asyncSupported = true) 
public class ObserverNotificationStreamServlet extends HttpServlet { 
 
@Override 
log.info("in notification/stream/observer"); 
 
 
 
AsyncContext asyncContext = request.startAsync(request, response); 
asyncContext.setTimeout((new Random().nextInt(5) + 5) * 1000); 
 
NotificationStreamObservable streamObservable = new NotificationStreamObservable(notificationStream); 
 
NotificationStreamObserver streamObserver = new NotificationStreamObserver(asyncContext); 
streamObservable.addObserver(streamObserver); 
asyncContext.addListener(streamObserver); 
 
streamObservable.subscribe(); 
 
log.info("out notification/stream/observer"); 
} 
 
String obtainUsername(HttpServletRequest request) { 
String username = request.getParameter("username"); 
if (StringUtils.hasText(username)) { 
return username; 
} 
 
return "anonymous"; 
}
 
}

 
 
Future<?> feedFuture; 
 
this.feedNotifies = requireNonNull(stream).feedNotifies(); 
} 
 
try { 
Notification notification = feedNotifies.next();
 
setChanged(); 
running = false; 
 
setChanged(); 
} 
}
//  
} 
}); 
} 
//
}

 
 
Future<?> feedFuture;
Iterator<Notification> friendNotifies; 
Future<?> friendFuture; 
 
this.feedNotifies = requireNonNull(stream).feedNotifies(); 
this.friendNotifies = requireNonNull(stream).friendRecommendationNotifies(); 
} 
 
try { 
Notification feedNotify = feedNotifies.next(); 
setChanged(); 
notifyObservers(feedNotify);
Notification friendNotify = friendNotifies.next(); 
setChanged(); 
notifyObservers(friendNotify); 
running = false; 
 
setChanged(); 
} 
}
//  
} 
}); 
} 
//
}

feedNotifies.next()
friendNotifies.next()
feedNotify
friendNotify

class NotificationPublisher implements Runnable { 
 
final Iterator<Notification> notifies; 
final AtomicBoolean running = new AtomicBoolean(true); 
 
NotificationPublisher(Iterator<Notification> notifies) { 
this.notifies = notifies; 
} 
 
@Override 
while (running.get()) { 
try { 
 
setChanged(); 
cancel(); 
 
setChanged(); 
} 
} 
 
cancel(); 
} 
 
Thread.yield(); 
} 
} 
 
void cancel() { 
running.set(false); 
} 
 
}

class MultipleNotificationStreamObservable extends Observable { 
 
final static ExecutorService executor = Executors.newCachedThreadPool(); 
 
NotificationPublisher feedPublisher; 
NotificationPublisher friendPublisher; 
 
public MultipleNotificationStreamObservable(NotificationStream stream) { 
this.feedPublisher = new NotificationPublisher(requireNonNull(stream).feedNotifies()); 
this.friendPublisher = new NotificationPublisher(requireNonNull(stream).friendRecommendationNotifies()); 
} 
 
executor.execute(feedPublisher); 
executor.execute(friendPublisher); 
} 
 
feedPublisher.cancel(); 
friendPublisher.cancel(); 
 
} 
 
}

class MultipleNotificationStreamObserver implements Observer, AsyncListener { 
 
@Override 
public void update(Observable observable, Object event) {
 
synchronized (this) { 
} 
 
//  
handlerError((Throwable) event); 
} 
}
 
} 
 
//
}

class MultipleNotificationStreamObserver implements Observer, AsyncListener { 
 
ReentrantLock reentrantLock = new ReentrantLock(); 
 
@Override 
 
reentrantLock.lock(); 
 
} 
 
//  
} 
 
reentrantLock.unlock();
 
} 
 
//
}

BlockingQueue<Object> notifyQueue = new LinkedBlockingQueue<>();
class SequentialNotifyObserversPublisher implements Runnable { 
 
 
SequentialNotifyObserversRunnable(Iterator<Notification> notifies) { 
} 
 
@Override 
while (running.get()) { 
try { 
notifyQueue.put(notifies.next()); 
cancel(); 
 
try { 
notifyQueue.put(error); 
} catch (InterruptedException ignore) { } 
} 
} 
 
cancel(); 
} 
 
Thread.yield(); 
} 
} 
 
void cancel() { 
} 
 
}

class MultipleNotificationStreamObservable extends Observable { 
 
final static ExecutorService executor = Executors.newFixedThreadPool(3); 
 
BlockingQueue<Object> notifyQueue = new LinkedBlockingQueue<>(); 
Future<?> notifyFuture; 
 
SequentialNotifyObserversPublisher sequentialFeed; 
SequentialNotifyObserversPublisher sequentialFriend; 
 
public MultipleNotificationStreamObservable(NotificationStream stream) { 
this.sequentialFeed = new SequentialNotifyObserversRunnable(stream.feedNotifies()); 
this.sequentialFriend = new SequentialNotifyObserversRunnable(stream.friendRecommendationNotifies()); 
} 
 
executor.execute(sequentialFeed); 
executor.execute(sequentialFriend); 
 
notifyFuture = executor.submit(() -> { 
try { 
Object event = notifyQueue.take(); 
 
setChanged(); 
notifyObservers(event); 
} catch (InterruptedException e) { 
running = false; 
} 
} 
running = false; 
} 
Thread.yield(); 
} 
}); 
} 
//  
}

void printUserInfo(String username) { 
 
NotifyApi.User user = notifyApi.getUser(username); 
Long feedCount = notifyApi.getFeedCount(username); 
Long friendCount = notifyApi.getFriendCount(username); 
 
UserInfo userInfo = new UserInfo(user.getName(), feedCount, friendCount); 
 
System.out.println("User Info"); 
System.out.println("name = " + userInfo.getName()); 
System.out.println("feedCount = " + userInfo.getFeedCount()); 
System.out.println("friendCount = " + userInfo.getFriendCount()); 
}
 
 
printUserInfo("fay"); // 1 
printUserInfo("murphy"); // 2 
printUserInfo("nichole"); // 3

void printUserInfo(String username) { … }
 
executorService.execute(() -> printUserInfo("fay")); // 1 
executorService.execute(() -> printUserInfo("murphy")); // 2 
executorService.execute(() -> printUserInfo("nichole")); // 3

void printUserInfo(String username) { … }
 
executorService.execute(() -> printUserInfo("fay")); // 1 
executorService.execute(() -> printUserInfo("murphy")); // 2 
executorService.execute(() -> printUserInfo("nichole")); // 3
 
executorService.execute(() -> printUserInfo("phillip")); // 4 
executorService.execute(() -> printUserInfo("adrienne")); // 5 
executorService.execute(() -> printUserInfo("nita")); // 6

 
CompletableFuture.supplyAsync(() -> notifyApi.getUser(username), executorService) 
.thenCompose(user -> { 
CompletableFuture<Long> feedCountCF = CompletableFuture.supplyAsync( 
() -> notifyApi.getFeedCount(username), executorService); 
 
CompletableFuture<Long> friendCountCF = CompletableFuture.supplyAsync( 
() -> notifyApi.getFriendCount(username), executorService); 
 
return feedCountCF.thenCombineAsync(friendCountCF, (feedCount, friendCount) -> { 
return new UserInfo(user.getName(), feedCount, friendCount); 
}, executorService); 
}) 
.thenAccept(userInfo -> { 
System.out.println("User Info"); 
System.out.println("name = " + userInfo.getName()); 
System.out.println("feedCount = " + userInfo.getFeedCount()); 
System.out.println("friendCount = " + userInfo.getFriendCount()); 
}); 
} 
 
printUserInfo("nichole"); // 3

 
//
 
} 
 
 
printUserInfo("nichole"); // 3 
 
printUserInfo("phillip"); // 4 
printUserInfo("adrienne"); // 5 
printUserInfo("nita"); // 6

 
Iterator<Notification> notifies; 
 
NotifyObserversRunnable(Iterator<Notification> notifies) { 
} 
 
@Override 
try { 
 
setChanged(); 
running = false; 
 
setChanged(); 
} 
} 
 
running = false; 
} 
 
Thread.yield(); 
} 
} 
 
}

final AtomicBoolean running = new AtomicBoolean(true);
 
NotifyObserversRunnable(Iterator<Notification> notifies) { 
} 
 
CompletableFuture<Object> completableFuture = new CompletableFuture<>(); 
completableFuture.thenAcceptAsync(event -> { 
if (running.get()) { 
setChanged(); 
} 
schedule(20); 
}, notifyExecutor).exceptionally(throwable -> { 
cancel(); 
setChanged(); 
notifyObservers(throwable); 
return null; 
}); 
try { 
completableFuture.complete(notifies.next()); 
completableFuture.completeExceptionally(error); 
} 
} 
schedule(50); 
}
 
void schedule(long millis) { 
serviceExecutor.schedule(this, millis, TimeUnit.MILLISECONDS); 
} 
}
 
void cancel() { 
} 
}

class AsyncMultipleNotificationStreamObservable extends Observable { 
 
final static ScheduledExecutorService serviceExecutor = Executors.newScheduledThreadPool(2); 
final static ScheduledExecutorService notifyExecutor = Executors.newScheduledThreadPool(1); 
 
NotifyObserversRunnable feedPublisher; 
NotifyObserversRunnable friendPublisher; 
 
public AsyncMultipleNotificationStreamObservable(NotificationStream stream) { 
this.feedPublisher = new NotifyObserversRunnable(requireNonNull(stream).feedNotifies()); 
this.friendPublisher = new NotifyObserversRunnable(requireNonNull(stream).friendRecommendationNotifies()); 
} 
 
serviceExecutor.schedule(feedPublisher, 10, TimeUnit.MILLISECONDS); 
serviceExecutor.schedule(friendPublisher, 10, TimeUnit.MILLISECONDS); 
} 
 
feedPublisher.cancel(); 
friendPublisher.cancel(); 
}
}

SocketChannel channel = SocketChannel.open(); 
channel.configureBlocking(true); 
 
Socket socket = channel.socket(); 
socket.connect(new InetSocketAddress("www.naver.com", 80)); 
 
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
PrintStream output = new PrintStream(socket.getOutputStream()); 
 
output.println("GET / HTTP/1.0"); 
output.println(); 
 
StringBuilder response = new StringBuilder(); 
String line = input.readLine(); 
while (Objects.nonNull(line)) { 
response.append(line).append("n"); 
line = input.readLine(); 
 
// body  
if ("".equals(line)) { 
while (Objects.nonNull(line)) { 
line = input.readLine(); 
} 
} 
} 
 
input.close(); 
output.close();

PollSelectorImpl
WindowsSelectorImpl
KQueueSelectorImpl
EPollSelectorImpl

Selector selector = Selector.open(); 
 
SocketChannel socketChannel = SocketChannel.open(); 
socketChannel.configureBlocking(false); 
 
socketChannel.connect(new InetSocketAddress("www.naver.com", 80)); 
socketChannel.register(selector, SelectionKey.OP_CONNECT); 
 
while (socketChannel.isOpen()) { 
if (selector.select() > 0) { 
Set<SelectionKey> selectionKeys = selector.selectedKeys(); 
Iterator<SelectionKey> iterator = selectionKeys.iterator(); 
 
while (iterator.hasNext()) { 
SelectionKey selectionKey = iterator.next(); 
 
if (selectionKey.isConnectable()) { 
SocketChannel channel = (SocketChannel) selectionKey.channel();
 
//
 
} else if (selectionKey.isWritable()) { 
SocketChannel channel = (SocketChannel) selectionKey.channel(); 
 
//  
 
} else if (selectionKey.isReadable()) { 
SocketChannel channel = (SocketChannel) selectionKey.channel(); 
 
//  
 
} 
//  
iterator.remove(); 
} 
} 
}

AsynchronousChannelGroup asynchronousChannelGroup = AsynchronousChannelGroup.withFixedThreadPool(1);
AsynchronousSocketChannel asynchronousSocketChannel = AsynchronousSocketChannel.open(asynchronousChannelGroup);
SocketAddress socketAddress = new InetSocketAddress(“www.naver.com”, 80); 
 
asynchronousSocketChannel.connect(socketAddress, null, new CompletionHandler<Void, Void>() { 
@Override 
public void completed(Void v, Void attachment) { 
//
 
asynchronousSocketChannel.write(writeBuffer, null, new CompletionHandler<Integer, Void>() { 
@Override 
public void completed(Integer length, Void attachment) {
//
 
asynchronousSocketChannel.read(readBuffer, null, new CompletionHandler<Integer, Void>() { 
@Override 
public void completed(Integer length, Void attachment) {
//
} 
@Override 
public void failed(Throwable error, Void attachment) { 
//  
} 
}); 
} 
@Override 
public void failed(Throwable error, Void attachment) { 
//  
} 
}); 
} 
@Override 
public void failed(Throwable exc, Void attachment) { 
//  
} 
});

✔ Netty(http://netty.io)
✔ gRPG(http://www.grpc.io)
✔ AsyncHttpClient(https://hc.apache.org/)

public FriendRecommendationNotify getRecommendationNotify(String username) throws ServiceOperationException { 
try { 
HttpGet request = new HttpGet(String.format(url, username, processing.name())); 
HttpResponse response = httpClient.execute(request); 
if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) { 
throw new ServiceOperationException(); 
} 
 
return objectMapper.readValue(response.getEntity().getContent(), FriendRecommendationNotify.class); 
} 
}

public CompletableFuture<FriendRecommendationNotify> getRecommendationNotifyAsync(String username) { 
CompletableFuture<FriendRecommendationNotify> completableFuture = new CompletableFuture<>(); 
 
HttpGet request = new HttpGet(String.format(url, username, processing.name())); 
httpAsyncClient.execute(request, new FutureCallback<HttpResponse>() { 
 
@Override 
public void completed(HttpResponse response) { 
try { 
int statusCode = response.getStatusLine().getStatusCode(); 
InputStream content = response.getEntity().getContent(); 
 
if (statusCode != HttpStatus.SC_OK) { 
completableFuture.completeExceptionally(new ServiceOperationException()); 
} 
 
completableFuture.complete(objectMapper.readValue(content, FriendRecommendationNotify.class)); 
completableFuture.completeExceptionally(new ServiceOperationException(error)); 
} 
} 
 
@Override 
public void failed(Exception error) { 
completableFuture.completeExceptionally(error); 
} 
 
@Override 
public void cancelled() { 
completableFuture.cancel(true); 
} 
 
}); 
 
return completableFuture; 
}

@Test 
public void getRecommendationNotify() throws Exception { 
StopWatch stopWatch = new StopWatch("recommendationNotify"); 
stopWatch.start(); 
 
IntStream.rangeClosed(1, 10) 
.mapToObj(value -> friendService.getRecommendationNotify("user-" + value)) 
.forEach(System.out::println); 
 
stopWatch.stop(); 
System.out.println(); 
System.out.println(stopWatch.prettyPrint()); 
} 
 
@Test 
public void getRecommendationNotifyAsync() throws Exception { 
StopWatch stopWatch = new StopWatch("recommendationNotifyAsync"); 
stopWatch.start(); 
 
IntStream.rangeClosed(1, 10) 
.mapToObj(value -> friendService.getRecommendationNotifyAsync("user-" + value)) 
.collect(Collectors.toList()) 
.stream() 
.map(CompletableFuture::join) 
.forEach(System.out::println); 
 
stopWatch.stop(); 
System.out.println(); 
System.out.println(stopWatch.prettyPrint()); 
}

 
final Supplier<CompletableFuture<Notification>> notifies; 
 
NotifyObserversRunnable(Supplier<CompletableFuture<Notification>> notifies) { 
} 
 
@Override 
notifies.get().thenAcceptAsync(event -> { 
setChanged(); 
} 
 
schedule(20); 
}, notifyExecutor).exceptionally(throwable -> { 
cancel(); 
setChanged(); 
notifyObservers(throwable); 
 
return null; 
}); 
} else { 
schedule(50); 
} 
} 
 
void schedule(long millis) { 
serviceExecutor.schedule(this, millis, TimeUnit.MILLISECONDS); 
} 
} 
 
void cancel() { 
} 
}

class NonBlockingAsyncMultipleNotificationStreamObservable extends Observable { 
 
final static ScheduledExecutorService serviceExecutor = Executors.newScheduledThreadPool(1); 
final static ScheduledExecutorService notifyExecutor = Executors.newScheduledThreadPool(1); 
 
NotifyObserversRunnable feed; 
NotifyObserversRunnable friend; 
 
public NonBlockingAsyncMultipleNotificationStreamObservable(NotificationStream stream) { 
requireNonNull(stream); 
 
this.feed = new NotifyObserversRunnable(stream::feedNotifyAsync); 
this.friend = new NotifyObserversRunnable(stream::friendRecommendationNotifyAsync); 
} 
 
serviceExecutor.execute(feed); 
serviceExecutor.execute(friend); 
} 
 
if (nonNull(feed)) feed.cancel(); 
if (nonNull(friend)) friend.cancel(); 
 
} 
}

class NonBlockingAsyncMultipleNotificationStreamObserver implements Observer, AsyncListener { 
 
final NonBlockingAsyncMultipleNotificationStreamObservable streamObservable; 
 
public NonBlockingAsyncMultipleNotificationStreamObserver(N…Observable streamObservable, AsyncContext asyncContext) { 
this.streamObservable = Objects.requireNonNull(streamObservable); 
} 
 
@Override 
} 
 
} 
} 
 
private void handler(Notification notification) { 
try { 
log.info("revised notification/stream/non-blocking-async-concurrency : " + notification.getEvent()); 
 
ServletOutputStream outputStream = asyncContext.getResponse().getOutputStream(); 
throw new DataWriteException(error); 
} 
} 
 
private void handlerError(Throwable error) { 
log.error("error notification/stream/non-blocking-async-concurrency : " + error.getMessage()); 
 
streamObservable.unsubscribe(); 
} 
}

✔ 비봉쇄 입/출력을 위한 새로운 인터페이스
•ReadListener - 사용 가능한 데이터를 읽을 수 있는 방법
•WriteListener - 데이터 쓰기가 가능한 때를 알 수 있는 방법
✔ ServletInputStream 에 추가된 기능
•isFinished()
•isReady()
•setReadListener()
✔ ServletOutputStream 에 추가된 기능
•isReady()
•setWriterListener()

ServletInputStream servletInputStream = request.getInputStream(); 
servletInputStream.setReadListener(new ReadListener() { 
 
@Override 
public void onDataAvailable() throws IOException { 
//  
} 
 
@Override 
public void onAllDataRead() throws IOException { 
//  
} 
 
@Override 
public void onError(Throwable throwable) { 
//  
} 
 
});
ServletOutputStream servletOutputStream = response.getOutputStream(); 
servletOutputStream.setWriteListener(new WriteListener() { 
 
@Override 
public void onWritePossible() throws IOException { 
//  
} 
 
@Override 
//  
} 
 
});

class NonBlockingAsyncMultipleNotificationStreamObserver implements Observer, AsyncListener, WriteListener { 
 
final NonBlockingAsyncMultipleNotificationStreamObservable streamObservable; 
final ServletOutputStream outputStream; 
 
final AtomicInteger counter = new AtomicInteger(1); 
 
public NonBlockingAsyncMultipleNotificationStreamObserver(N…Observable streamObservable, AsyncContext asyncContext) { 
this.streamObservable = Objects.requireNonNull(streamObservable); 
this.outputStream = asyncContext.getResponse().getOutputStream(); 
} 
//
 
@Override 
public void onWritePossible() throws IOException { 
// ignore 
} 
 
@Override 
handlerError(throwable); 
} 
 
private void handler(Notification notification) { 
String content = notification.toContent(); 
 
ioExecutor.schedule(() -> write(content.getBytes()), 10, TimeUnit.MILLISECONDS); 
} 
private void handlerError(Throwable error) { 
log.error("error notification/stream/non-blocking-async-concurrency : " + error.getMessage()); 
 
streamObservable.unsubscribe(); 
}
// …

//
final static ScheduledExecutorService ioExecutor = Executors.newScheduledThreadPool(1);
 
private void write(byte[] data) { 
if (outputStream.isReady()) { 
try { 
outputStream.write(data); 
 
ioExecutor.schedule(this::flush, 10, TimeUnit.MILLISECONDS); 
handlerError(error); 
} 
} else { 
ioExecutor.schedule(() -> write(data), 10, TimeUnit.MILLISECONDS); 
} 
} 
 
private void flush() { 
if (outputStream.isReady()) { 
try { 
handlerError(error); 
} 
} else { 
ioExecutor.schedule(this::flush, 10, TimeUnit.MILLISECONDS); 
} 
} 
 
}

Reactive Web - Servlet & Async, Non-blocking I/O

Reactive Web - Servlet & Async, Non-blocking I/O

More Related Content

What's hot

Viewers also liked

More from Arawn Park

Recently uploaded

Reactive Web - Servlet & Async, Non-blocking I/O