/** Stops unicast and multicast receiver threads */ void stopThreads() { Thread tmp; // 1. Stop the multicast receiver thread if (mcast_receiver != null) { if (mcast_receiver.isAlive()) { tmp = mcast_receiver; mcast_receiver = null; closeMulticastSocket(); // will cause the multicast thread to terminate tmp.interrupt(); try { tmp.join(100); } catch (Exception e) { } tmp = null; } mcast_receiver = null; } // 2. Stop the unicast receiver thread if (ucast_receiver != null) { ucast_receiver.stop(); ucast_receiver = null; } // 3. Stop the in_packet_handler thread if (incoming_packet_handler != null) { incoming_packet_handler.stop(); } }
synchronized void waitUntilCompleted(long timeout, boolean resume) { if (thread != null) { try { thread.join(timeout); } catch (InterruptedException e) { Thread.currentThread().interrupt(); // set interrupt flag again } thread = null; // Added after Brian noticed that ViewHandler leaks class loaders } if (resume) resumeForce(); }
protected void stopFlusher() { flushing = false; Thread tmp = flusher; while (tmp != null && tmp.isAlive()) { tmp.interrupt(); ack_promise.setResult(null); try { tmp.join(); } catch (InterruptedException e) { } } }
/** * Tests concurrent reception of multiple messages with a different conn_id * (https://issues.jboss.org/browse/JGRP-1347) */ public void testMultipleConcurrentResets() throws Exception { sendAndCheck(a, b_addr, 1, r2); // now close connection on A unilaterally System.out.println("==== Closing the connection on A"); removeConnection(u1, b_addr); r2.clear(); final UNICAST unicast = (UNICAST) b.getProtocolStack().findProtocol(UNICAST.class); int NUM = 10; final List<Message> msgs = new ArrayList<Message>(NUM); for (int i = 1; i <= NUM; i++) { Message msg = new Message(b_addr, a_addr, "m" + i); UNICAST.UnicastHeader hdr = UNICAST.UnicastHeader.createDataHeader(1, (short) 2, true); msg.putHeader(unicast.getId(), hdr); msgs.add(msg); } Thread[] threads = new Thread[NUM]; final CyclicBarrier barrier = new CyclicBarrier(NUM + 1); for (int i = 0; i < NUM; i++) { final int index = i; threads[i] = new Thread() { public void run() { try { barrier.await(); unicast.up(new Event(Event.MSG, msgs.get(index))); } catch (Exception e) { e.printStackTrace(); } } }; threads[i].start(); } barrier.await(); for (Thread thread : threads) thread.join(); List<Message> list = r2.getMessages(); System.out.println("list = " + print(list)); assert list.size() == 1 : "list must have 1 element but has " + list.size() + ": " + print(list); }
/** Tests 2 channels calling FLUSH simultaneously */ @Test public void testConcurrentFlush() throws Exception { c1 = createChannel(true, 2); c1.connect("testConcurrentFlush"); c2 = createChannel(c1); c2.connect("testConcurrentFlush"); assertViewsReceived(c1, c2); final CountDownLatch startFlushLatch = new CountDownLatch(1); final CountDownLatch stopFlushLatch = new CountDownLatch(1); final CountDownLatch flushStartReceived = new CountDownLatch(2); final CountDownLatch flushStopReceived = new CountDownLatch(2); Thread t1 = new Thread() { public void run() { try { startFlushLatch.await(); boolean rc = Util.startFlush(c1); System.out.println("t1: rc=" + rc); } catch (InterruptedException e) { interrupt(); } try { stopFlushLatch.await(); } catch (InterruptedException e) { interrupt(); } finally { c1.stopFlush(); } } }; Thread t2 = new Thread() { public void run() { try { startFlushLatch.await(); boolean rc = Util.startFlush(c2); System.out.println("t2: rc=" + rc); } catch (InterruptedException e) { interrupt(); } try { stopFlushLatch.await(); } catch (InterruptedException e) { interrupt(); } finally { c2.stopFlush(); } } }; Listener l1 = new Listener("c1", c1, flushStartReceived, flushStopReceived); Listener l2 = new Listener("c2", c2, flushStartReceived, flushStopReceived); t1.start(); t2.start(); startFlushLatch.countDown(); assertTrue(flushStartReceived.await(60, TimeUnit.SECONDS)); // at this stage both channels should have started a flush stopFlushLatch.countDown(); t1.join(); t2.join(); assertTrue(flushStopReceived.await(60, TimeUnit.SECONDS)); assert l1.blockReceived; assert l1.unblockReceived; assert l2.blockReceived; assert l2.unblockReceived; }
/** Tests 2 channels calling partial FLUSHes and one calling FLUSH simultaneously */ @Test public void testConcurrentFlushAndPartialFlush() throws Exception { c1 = createChannel(true, 3); c1.connect("testConcurrentFlushAndPartialFlush"); c2 = createChannel(c1); c2.connect("testConcurrentFlushAndPartialFlush"); c3 = createChannel(c1); c3.connect("testConcurrentFlushAndPartialFlush"); assertViewsReceived(c1, c2, c3); final CountDownLatch startFlushLatch = new CountDownLatch(1); final CountDownLatch stopFlushLatch = new CountDownLatch(1); // 2 because either total or partial has to finish first final CountDownLatch flushStartReceived = new CountDownLatch(2); // 5 because we have total and partial flush final CountDownLatch flushStopReceived = new CountDownLatch(5); Thread t1 = new Thread() { public void run() { try { startFlushLatch.await(); boolean rc = Util.startFlush(c1); System.out.println("t1: rc=" + rc); } catch (InterruptedException e) { interrupt(); } try { stopFlushLatch.await(); } catch (InterruptedException e) { interrupt(); } finally { c1.stopFlush(); } } }; Thread t2 = new Thread() { public void run() { try { startFlushLatch.await(); // partial, only between c2 and c3 boolean rc = Util.startFlush(c2, (Arrays.asList(c2.getAddress(), c3.getAddress()))); System.out.println("t2: partial flush rc=" + rc); } catch (InterruptedException e) { interrupt(); } try { stopFlushLatch.await(); } catch (InterruptedException e) { interrupt(); } finally { c2.stopFlush(Arrays.asList(c2.getAddress(), c3.getAddress())); } } }; Listener l1 = new Listener("c1", c1, flushStartReceived, flushStopReceived); Listener l2 = new Listener("c2", c2, flushStartReceived, flushStopReceived); Listener l3 = new Listener("c3", c3, flushStartReceived, flushStopReceived); t1.start(); t2.start(); startFlushLatch.countDown(); assertTrue(flushStartReceived.await(60, TimeUnit.SECONDS)); // at this stage both channels should have started a flush? stopFlushLatch.countDown(); t1.join(); t2.join(); assertTrue(flushStopReceived.await(60, TimeUnit.SECONDS)); assert l1.blockReceived; assert l1.unblockReceived; assert l2.blockReceived; assert l2.unblockReceived; assert l3.blockReceived; assert l3.unblockReceived; }