Concurrent processing of Java. util. Concurrent package)

We all know that before jdk1.5, when Java needs to implement business concurrency, programmers usually need to implement Code independently. When designing high quality Java multi-thread concurrent programs, to prevent the appearance of such phenomena as death, such as using wait (), Y (), and synchronized before Java, every time you need to consider performance, deadlock, fairness, resource management, and how to avoid the harm caused by thread security, some complicated security policies are often used, increases the development burden of programmers. fortunately, after the emergence of jdk1.5, Sun finally launched Java for our poor programmers. util. concurrent toolkit to simplify concurrency. With this, developers can effectively reduce race conditions and deadlock threads. The concurrent package solves these problems and provides us with a more practical concurrent program model.

Main interfaces and classes in Java. util. Concurrent:

Executor: executor of a specific runnable task.

Executorservice: A thread pool manager, whose implementation classes include common thread pools and regular scheduling thread pools scheduledexecutorservice.

Runnable and callable are submitted to the pool for scheduling.

Future: it is an interface that interacts with runnable and callable. For example, a thread obtains the returned results after execution ends, and a cancel termination thread is also provided.

Blockingqueue: blocking the queue.

Below is a simple example program:

Futureproxy. JavaView copies to clipboard Printing

1. Package org. Test. Concurrent;
2. /***//**
3. * <P> title: loonframework </P>
4. * <P> Description: Processing in future mode </P>
5. * <P> copyright: Copyright (c) 2007 </P>
6. * <P> company: loonframework </P>
7. * @ Author chenpeng
8. * @ Email: ceponline@yahoo.com.cn
9. * @ Version 0.1
10. */
11. Import java. Lang. Reflect. invocationhandler;
12. Import java. Lang. Reflect. method;
13. Import java. Lang. Reflect. proxy;
14. Import java. util. Concurrent. callable;
15. Import java. util. Concurrent. executorservice;
16. Import java. util. Concurrent. executors;
17. Import java. util. Concurrent. Future;
18. Import java. util. Concurrent. threadfactory;
20. Public abstract class futureproxy <t> {
22. Private final class callableimpl implements callable <t> {
24. Public t call () throws exception {
25. Return futureproxy. This. createinstance ();
26. }
27. }
29. Private Static class invocationhandlerimpl <t> implements invocationhandler {
31. Private future <t> future;
33. Private volatile t instance;
35. Invocationhandlerimpl (Future <t> future ){
36. This. Future = future;
37. }
39. Public object invoke (Object proxy, method, object [] ARGs)
40. Throws throwable {
41. Synchronized (this ){
42. If (this. Future. isdone ()){
43. This. instance = This. Future. Get ();
44. } Else {
45. While (! This. Future. isdone ()){
46. Try {
47. This. instance = This. Future. Get ();
48. } Catch (interruptedexception e ){
49. Thread. currentthread (). Interrupt ();
50. }
51. }
52. }
54. Return method. Invoke (this. instance, argS );
55. }
56. }
57. }
59. /***//**
60. * Implement the java. util. Concurrent. threadfactory Interface
61. * @ Author chenpeng
62. *
63. */
64. Private Static final class threadfactoryimpl implements threadfactory {
66. Public thread newthread (runnable R ){
67. Thread thread = new thread (R );
68. Thread. setdaemon (true );
69. Return thread;
70. }
71. }
73. Private Static executorservice service = executors. newcachedthreadpool (New threadfactoryimpl ());
75. Protected abstract t createinstance ();
77. Protected abstract class <? Extends T> getinterface ();
79. /***//**
80. * Returns the proxy instance.
81. * @ Return
82. */
83. @ Suppresswarnings ("unchecked ")
84. Public final t getproxyinstance (){
85. Class <? Extends T> interfaceclass = This. getinterface ();
86. If (interfaceclass = NULL |! Interfaceclass. isinterface ()){
87. Throw new illegalstateexception ();
88. }
90. Callable <t> task = new callableimpl ();
92. Future <t> future = futureproxy. Service. Submit (task );
94. Return (t) proxy. newproxyinstance (interfaceclass. getclassloader (),
95. New Class <?> [] {Interfaceclass}, new invocationhandlerimpl (Future ));
96. }
97. }

Package Org. test. concurrent;/*** // *** <p> title: loonframework </P> * <p> description: processing in future mode </P> * <p> copyright: Copyright (c) 2007 </P> * <p> company: loonframework </P> * @ author chenpeng * @ Email: ceponline@yahoo.com.cn * @ version 0.1 */import Java. lang. reflect. invocationhandler; import Java. lang. reflect. method; import Java. lang. reflect. proxy; import Java. util. concurrent. callable; import Java. util. conc Urrent. executorservice; import Java. util. concurrent. executors; import Java. util. concurrent. future; import Java. util. concurrent. threadfactory; public abstract class futureproxy <t> {private final class callableimpl implements callable <t> {public t call () throws exception {return futureproxy. this. createinstance () ;}} Private Static class invocationhandlerimpl <t> implements invocationhandler {private Future <t> future; private volatile t instance; invocationhandlerimpl (Future <t> future) {This. future = Future;} public object invoke (Object proxy, method, object [] ARGs) throws throwable {synchronized (this) {If (this. future. isdone () {This. instance = This. future. get ();} else {While (! This. future. isdone () {try {This. instance = This. future. get ();} catch (interruptedexception e) {thread. currentthread (). interrupt () ;}} return method. invoke (this. instance, argS) ;}}/ ***** // *** implement Java. util. concurrent. threadfactory interface * @ author chenpeng */Private Static final class threadfactoryimpl implements threadfactory {public thread newthread (runnable R) {thread = new thread (R ); Thread. setdaemon (true); Return thread ;}} Private Static executorservice service = executors. newcachedthreadpool (New threadfactoryimpl (); protected abstract t createinstance (); protected abstract class <? Extends T> getinterface ();/*** // *** return proxy instance * @ return */@ suppresswarnings ("unchecked") Public final t getproxyinstance () {class <? Extends T> interfaceclass = This. getinterface (); If (interfaceclass = NULL |! Interfaceclass. isinterface () {Throw new illegalstateexception ();} callable <t> task = new callableimpl (); Future <t> future = futureproxy. service. submit (task); Return (t) proxy. newproxyinstance (interfaceclass. getclassloader (), new class <?> [] {Interfaceclass}, new invocationhandlerimpl (Future ));}}

Test. JavaView copies to clipboard Printing

1. Package org. Test. Concurrent;
3. Import java. util. calendar;
5. /***//**
6. * <P> title: loonframework </P>
7. * <P> Description: </P>
8. * <P> copyright: Copyright (c) 2007 </P>
9. * <P> company: loonframework </P>
10. * @ Author chenpeng
11. * @ Email: ceponline@yahoo.com.cn
12. * @ Version 0.1
13. */
14. Interface datetest {
16. String getdate ();
17. }
19. Class datetestimpl implements datetest {
21. Private string _ date = NULL;
23. Public datetestimpl (){
24. Try {
25. _ Date + = calendar. getinstance (). gettime ();
26. // Set the latency of five seconds
27. Thread. Sleep (5000 );
28. } Catch (interruptedexception e ){
29. }
30. }
32. Public String getdate (){
34. Return "date" + _ date;
35. }
36. }
38. Class datetestfactory extends futureproxy <datetest> {
40. @ Override
41. Protected datetest createinstance (){
42. Return new datetestimpl ();
43. }
45. @ Override
46. Protected class <? Extends datetest> getinterface (){
47. Return datetest. Class;
48. }
49. }
51. Public class test {
53. Public static void main (string [] ARGs ){
55. Datetestfactory factory = new datetestfactory ();
56. Datetest [] DTS = new datetest [100];
57. For (INT I = 0; I <DTS. length; I ++ ){
58. DTS [I] = factory. getproxyinstance ();
59. }
60. // Execute Traversal
61. For (datetest DT: DTS ){
62. System. Out. println (Dt. getdate ());
63. }
65. }
66. }