1. ARVIND KRISHNAA J CSE 'A' III YEAR MULTITHREADING CONCEPTS

3. Executors

4. Synchronizers

5. Threads and swing

8. Choose a thread safe implementation of the data structure

10. EFFICIENT MAPS

11. SETS

13. One thread insert items into the queue. Another removes an item.

14. FUNCTIONALITY: Causes a thread to block when an element is being added to a full queue (or) when an element is being removed from an empty queue.

18. LinkedBlockingDeque()

19. LinkedBlockingQueue(int capacity)

20. LinkedBlockingDeque(int capacity)

22. PriorityBlockingQueue()

23. PriorityBlockingQueue(int initialcapacity)

24. (initial capacity is 11 by default)

25. PriorityBlockingQueue(int initialcapacity,Comparator <? super E> comparator>

27. (a) Thread management tool

28. (b) Synchronization tool

29. (c) Simple data structure

30. Methods :

31. (i) boolean add(E o) throws IllegalStateException: Adds the specified element to the queue

32. (ii)E remove() throws NoSuchElementException: Deletes an element from the queue

34. boolean offer(E o , long timeOut,TimeUnit unit)

35. Tries for ”timeOut” time units to insert an element into the tail of the queue. If not possible returns with an error instead of throwing an exception.

36. boolean poll()

37. boolean poll(long timeOut,Timeunit unit)

38. Tries for ”timeOut” time units to remove an element from the head of the queue. If not possible returns with an error.

40. E take(): Removes and returns the header element. Blocks if the queue is empty.

41. E element() throws NoSuchElementException: Returns the header element.

42. E peek(): Returns the header element. Returns null if queue is empty.

44. Supports a large number of readers and writers

45. Methods:

46. (a) putIfAbsent(key,value)

47. (b) remove(key,value)

48. (c) replace(key,oldvalue,newvalue)

51. ConcurrentLinkedQueue : Unbounded non-blocking queue that can be safely accessed by multiple threads.

52. CopyOnWriteArrayList and CopyOnWriteArraySet

53. Useful if the number of iterators on the base array outnumber the number of mutators.

54. Each iterator has a reference to the old array.

56. (a) Vector

57. (b) Hashtable

58. Synchronization Wrapper

59. List <E> syncharraylist=Collections.synchronizedList(new ArrayList <E> ());

60. Map<K,V> synchHashMap=Collections.synchronizedMap(new HashMap <K,V> ());

62. Methods :

63. (a) newCachedThreadPool() : Constructs a thread pool that executes each task immediately.using an existing idle thread when available and creating a new thread otherwise.

64. (b) newFixedThreadPool() : Constructs a thread pool with a fixed size. If more tasks are submitted than available threads the unserved tasks are placed on a queue

65. (c) newSingleThreadExecutor() : A ”pool” with a single thread that executes the submitted tasks sequentially.

67. A runnable task can be submitted to the thread pool to execute its run() method.

68. (i) Future<?> submit(Runnable task)

69. (ii) Future<T> submit(Runnable task,T result)

70. (iii) Future<T> submit(Callable <T> task)

72. Call submit to submit Runnable or Callable objects

73. To manipulate the tasks use the returned Future objects

74. Call shutdown when no more tasks need to be submitted

76. (a) newScheduledThreadPool(int threads): Returns a thread pool that uses the given number of threads to schedule tasks.

77. (b) newSingleThreadScheduledExecutor(): Returns an executor that schedules tasks in a single thread.

79. Methods:

80. ScheduledFuture<V> schedule(Callable <V> task,long time,TimeUnit unit)

81. ScheduledFuture<?>schedule(Runnable task,long time,TimeUnit unit)

82. ScheduledFuture<?>scheduleAtFixedRate(Runnable task,long initialDelay,long period,TimeUnit unit)

83. ScheduledFuture<?> scheduleWithFixedDelay(Runnable task,long initialDelay,long delay,TimeUnit unit)

85. Methods available:

86. T invokeAny(Collection <Callable<T>> tasks)

87. T invokeAny(Collection <Callable<T>> tasks,long timeout,Timeunit unit)

88. List<Future<T>> invokeAll(Collection<Callable<T>> tasks)

89. List<Future<T>> invokeAll(Collection<Callable<T>> tasks,long timeOut,TimeUnit unit)

91. Constructs an executor completion service that collects the results of the given executor

92. Future<T> submit(Callable<T> task)

93. Future<T> submit(Runnable task,T result):

94. Submits a task to the underlying executor

95. Future<T> take() : Removes the next completed result,blocking if no completed results are available.

96. Future<T> poll()

97. Future<T> poll(long time,TimeUnit unit) : removes the next completed result or null if no completed results are available.

99. Synchronizers (contd) Exchanger Allows two threads to exchange objects when both are ready for the exchange. When two threads work on two instances of the same data structure , one by filling an instance and other by emptying the others Semaphore Allows a set of threads to wait until permits are available fot proceeding To restrict the total number of threads that can access a resource. If permit count is one , use to block threads until another thread gives permission SynchronousQueue Allows a thread to hand off an object to another thread To send an object from one thread to another when both are ready,without explicit synchronization

101. (1)CylicBarrier(int parties)

102. (2)CyclicBarrier(int parties,Runnable barrierAction)

103. (3)int await()

104. (4) int await(long time, TimeUnit unit):

105. Waits until all parties have called await on the barrier or until the timeout has been reached, in which case a TimeoutException is thrown. Upon success, returns the arrival index of this party. The first party has index parties - 1, and the last party has index 0.

111. Swing is not ”thread safe”

112. If user interface elements are manipulated from multiple threads then the user interface can become corrupted

113. Running time consuming tasks:

114. (a) If an action takes a long time , do it in a separate worker thread and never in the event dispatch thread

115. (b) Do not touch Swing components in any thread other than the event dispatch thread

116. Use the invokeLater() or the invokeAndWait() methods to update swing components when needed.

119. Small number of Swing methods are thread safe

120. (a) JtextComponent.setText

121. (b) JtextArea.insert

122. (c) JtextArea.append

123. (d) JtextArea.replaceRange

124. (e) Jcomponent.repaint

125. (f) Jcomponent.revalidate