Java多线程之并发锁

这是自JDK5.0开始提供的Java并发包里面的类

下面是关于Java并发锁的测试代码

1. packagecom.jadyer.thread.lock;
3. importjava.util.concurrent.locks.Lock;
4. importjava.util.concurrent.locks.ReentrantLock;
6. /**
7. *LockTest
8. *@author宏宇
9. *@createMar1,20127:12:04PM
10. */
11. publicclassLockTest{
12. publicstaticvoidmain(String[]args){
13. FoodCenterfc=newFoodCenter();
14. newThread(newThreadDog(fc,"Itisdog`sfood")).start();
15. newThread(newThreadPig(fc,"Itispig`sfood")).start();
16. }
17. }
20. classThreadDogimplementsRunnable{
21. privateFoodCenterfc;
22. privateStringfoodname;
23. publicThreadDog(FoodCenterfc,Stringfoodname){
24. this.fc=fc;
25. this.foodname=foodname;
26. }
27. @Override
28. publicvoidrun(){
29. while(true){
30. try{
31. Thread.sleep(1000);
32. }catch(InterruptedExceptione){
33. e.printStackTrace();
34. }
35. fc.getFood(foodname);
36. }
37. }
38. }
41. classThreadPigimplementsRunnable{
42. privateFoodCenterfc;
43. privateStringfoodname;
44. publicThreadPig(FoodCenterfc,Stringfoodname){
45. this.fc=fc;
46. this.foodname=foodname;
47. }
48. @Override
49. publicvoidrun(){
50. while(true){
51. try{
52. Thread.sleep(2000);
53. }catch(InterruptedExceptione){
54. e.printStackTrace();
55. }
56. fc.getFood(foodname);
57. }
58. }
59. }
62. /**
63. *@see=========================================================================================
64. *@seejava.util.concurrent是JDK5.0开始提供的Java并发包，其子包locks是专门用于处理线程锁的
65. *@seejava.util.concurrent.locks.Lock较synchronized关键字比，有一个最大的区别，那就是
66. *@seeLock可以比synchronized更细粒度的控制锁，体现在try{...}finally{mylock.unlock();}
67. *@see=========================================================================================
68. *@seeLock有点像公共厕所的门闩，只有正在使用厕所的人，把门闩打开出来了，其它人才可以使用公厕
69. *@seeLock比传统线程模型中的synchronized方式更加面向对象。与生活中的锁类似，锁本身也应该是一个对象
70. *@see两个线程执行的代码片段要实现同步互斥的效果，那么这两个线程所使用的必须是同一个Lock对象
71. *@see并且，锁应该位于待操作的资源类的内部方法中，而非线程代码中
72. *@see=========================================================================================
73. */
74. classFoodCenter{
75. Lockmylock=newReentrantLock();//创建一个锁
76. publicvoidgetFood(Stringname){
77. intlen=name.length();
78. mylock.lock();//上锁
79. try{
80. for(inti=0;i<len;i++){
81. System.out.print(name.charAt(i));
82. }
83. System.out.println();
84. }finally{
85. mylock.unlock();//解锁
86. }
87. }
88. }

下面是关于Java读写锁的测试代码

1. packagecom.jadyer.thread.lock;
3. importjava.util.concurrent.locks.ReadWriteLock;
4. importjava.util.concurrent.locks.ReentrantReadWriteLock;
6. /**
7. *Java读写锁
8. *@see锁分为读锁和写锁。多个读锁不互斥。读锁与写锁互斥。写锁与写锁互斥。这是由JVM自己控制的
9. *@see如果代码只读数据，可以很多人同时读，但不能同时写，那就上读锁
10. *@see如果代码修改数据，并且不允许同时读，只能一个人写，那就上写锁
11. *@see总之：读的时候上读锁，写的时候上写锁
12. */
13. publicclassReadWriteLockDemo{
14. privateObjectmyData=null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据
15. ReadWriteLockrwl=newReentrantReadWriteLock();
17. publicvoidget(){
18. rwl.readLock().lock();//读锁
19. try{
20. System.out.println(Thread.currentThread().getName()+"bereadytoreaddata");
21. Thread.sleep((long)(Math.random()*1000));
22. System.out.println(Thread.currentThread().getName()+"havereaddata:"+myData);
23. }catch(InterruptedExceptione){
24. e.printStackTrace();
25. }finally{
26. rwl.readLock().unlock();
27. }
28. }
30. publicvoidput(Objectdata){
31. rwl.writeLock().lock();//写锁
32. try{
33. System.out.println(Thread.currentThread().getName()+"bereadytowritedata");
34. Thread.sleep((long)(Math.random()*1000));
35. this.myData=data;
36. System.out.println(Thread.currentThread().getName()+"havewritedata:"+myData);
37. }catch(InterruptedExceptione){
38. e.printStackTrace();
39. }finally{
40. rwl.writeLock().unlock();
41. }
42. }
43. }