743 * tryConvertToOptimisticRead succeeds and validates if successfully locked, |
743 * tryConvertToOptimisticRead succeeds and validates if successfully locked, |
744 */ |
744 */ |
745 public void testTryConvertToOptimisticRead() throws InterruptedException { |
745 public void testTryConvertToOptimisticRead() throws InterruptedException { |
746 StampedLock lock = new StampedLock(); |
746 StampedLock lock = new StampedLock(); |
747 long s, p; |
747 long s, p; |
748 s = 0L; |
748 assertEquals(0L, lock.tryConvertToOptimisticRead(0L)); |
749 assertFalse((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
749 |
750 assertTrue((s = lock.tryOptimisticRead()) != 0L); |
750 assertTrue((s = lock.tryOptimisticRead()) != 0L); |
751 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
751 assertEquals(s, lock.tryConvertToOptimisticRead(s)); |
|
752 assertTrue(lock.validate(s)); |
|
753 |
|
754 assertTrue((p = lock.readLock()) != 0L); |
|
755 assertTrue((s = lock.tryOptimisticRead()) != 0L); |
|
756 assertEquals(s, lock.tryConvertToOptimisticRead(s)); |
|
757 assertTrue(lock.validate(s)); |
|
758 lock.unlockRead(p); |
|
759 |
752 assertTrue((s = lock.writeLock()) != 0L); |
760 assertTrue((s = lock.writeLock()) != 0L); |
753 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
761 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
754 assertTrue(lock.validate(p)); |
762 assertTrue(lock.validate(p)); |
|
763 |
755 assertTrue((s = lock.readLock()) != 0L); |
764 assertTrue((s = lock.readLock()) != 0L); |
756 assertTrue(lock.validate(s)); |
765 assertTrue(lock.validate(s)); |
757 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
766 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
758 assertTrue(lock.validate(p)); |
767 assertTrue(lock.validate(p)); |
|
768 |
759 assertTrue((s = lock.tryWriteLock()) != 0L); |
769 assertTrue((s = lock.tryWriteLock()) != 0L); |
760 assertTrue(lock.validate(s)); |
770 assertTrue(lock.validate(s)); |
761 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
771 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
762 assertTrue(lock.validate(p)); |
772 assertTrue(lock.validate(p)); |
|
773 |
763 assertTrue((s = lock.tryReadLock()) != 0L); |
774 assertTrue((s = lock.tryReadLock()) != 0L); |
764 assertTrue(lock.validate(s)); |
775 assertTrue(lock.validate(s)); |
765 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
776 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
766 assertTrue(lock.validate(p)); |
777 assertTrue(lock.validate(p)); |
|
778 |
767 assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); |
779 assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); |
768 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
780 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
769 assertTrue(lock.validate(p)); |
781 assertTrue(lock.validate(p)); |
|
782 |
770 assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); |
783 assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); |
771 assertTrue(lock.validate(s)); |
784 assertTrue(lock.validate(s)); |
772 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
785 assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L); |
773 assertTrue(lock.validate(p)); |
786 assertTrue(lock.validate(p)); |
774 } |
787 } |
778 * or lock free; |
791 * or lock free; |
779 */ |
792 */ |
780 public void testTryConvertToReadLock() throws InterruptedException { |
793 public void testTryConvertToReadLock() throws InterruptedException { |
781 StampedLock lock = new StampedLock(); |
794 StampedLock lock = new StampedLock(); |
782 long s, p; |
795 long s, p; |
783 s = 0L; |
796 |
784 assertFalse((p = lock.tryConvertToReadLock(s)) != 0L); |
797 assertFalse((p = lock.tryConvertToReadLock(0L)) != 0L); |
|
798 |
785 assertTrue((s = lock.tryOptimisticRead()) != 0L); |
799 assertTrue((s = lock.tryOptimisticRead()) != 0L); |
786 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
800 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
|
801 assertTrue(lock.isReadLocked()); |
|
802 assertEquals(1, lock.getReadLockCount()); |
787 lock.unlockRead(p); |
803 lock.unlockRead(p); |
|
804 |
|
805 assertTrue((s = lock.tryOptimisticRead()) != 0L); |
|
806 lock.readLock(); |
|
807 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
|
808 assertTrue(lock.isReadLocked()); |
|
809 assertEquals(2, lock.getReadLockCount()); |
|
810 lock.unlockRead(p); |
|
811 lock.unlockRead(p); |
|
812 |
788 assertTrue((s = lock.writeLock()) != 0L); |
813 assertTrue((s = lock.writeLock()) != 0L); |
789 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
814 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
790 assertTrue(lock.validate(p)); |
815 assertTrue(lock.validate(p)); |
|
816 assertTrue(lock.isReadLocked()); |
|
817 assertEquals(1, lock.getReadLockCount()); |
791 lock.unlockRead(p); |
818 lock.unlockRead(p); |
|
819 |
792 assertTrue((s = lock.readLock()) != 0L); |
820 assertTrue((s = lock.readLock()) != 0L); |
793 assertTrue(lock.validate(s)); |
821 assertTrue(lock.validate(s)); |
|
822 assertEquals(s, lock.tryConvertToReadLock(s)); |
|
823 assertTrue(lock.validate(s)); |
|
824 assertTrue(lock.isReadLocked()); |
|
825 assertEquals(1, lock.getReadLockCount()); |
|
826 lock.unlockRead(s); |
|
827 |
|
828 assertTrue((s = lock.tryWriteLock()) != 0L); |
|
829 assertTrue(lock.validate(s)); |
794 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
830 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
795 assertTrue(lock.validate(p)); |
831 assertTrue(lock.validate(p)); |
|
832 assertEquals(1, lock.getReadLockCount()); |
796 lock.unlockRead(p); |
833 lock.unlockRead(p); |
797 assertTrue((s = lock.tryWriteLock()) != 0L); |
834 |
798 assertTrue(lock.validate(s)); |
|
799 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
|
800 assertTrue(lock.validate(p)); |
|
801 lock.unlockRead(p); |
|
802 assertTrue((s = lock.tryReadLock()) != 0L); |
835 assertTrue((s = lock.tryReadLock()) != 0L); |
803 assertTrue(lock.validate(s)); |
836 assertTrue(lock.validate(s)); |
804 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
837 assertEquals(s, lock.tryConvertToReadLock(s)); |
805 assertTrue(lock.validate(p)); |
838 assertTrue(lock.validate(s)); |
806 lock.unlockRead(p); |
839 assertTrue(lock.isReadLocked()); |
|
840 assertEquals(1, lock.getReadLockCount()); |
|
841 lock.unlockRead(s); |
|
842 |
807 assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); |
843 assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); |
808 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
844 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
809 assertTrue(lock.validate(p)); |
845 assertTrue(lock.validate(p)); |
|
846 assertTrue(lock.isReadLocked()); |
|
847 assertEquals(1, lock.getReadLockCount()); |
810 lock.unlockRead(p); |
848 lock.unlockRead(p); |
|
849 |
811 assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); |
850 assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); |
812 assertTrue(lock.validate(s)); |
851 assertTrue(lock.validate(s)); |
813 assertTrue((p = lock.tryConvertToReadLock(s)) != 0L); |
852 assertEquals(s, lock.tryConvertToReadLock(s)); |
814 assertTrue(lock.validate(p)); |
853 assertTrue(lock.validate(s)); |
815 lock.unlockRead(p); |
854 assertTrue(lock.isReadLocked()); |
|
855 assertEquals(1, lock.getReadLockCount()); |
|
856 lock.unlockRead(s); |
816 } |
857 } |
817 |
858 |
818 /** |
859 /** |
819 * tryConvertToWriteLock succeeds and validates if successfully locked |
860 * tryConvertToWriteLock succeeds and validates if successfully locked |
820 * or lock free; |
861 * or lock free; |
821 */ |
862 */ |
822 public void testTryConvertToWriteLock() throws InterruptedException { |
863 public void testTryConvertToWriteLock() throws InterruptedException { |
823 StampedLock lock = new StampedLock(); |
864 StampedLock lock = new StampedLock(); |
824 long s, p; |
865 long s, p; |
825 s = 0L; |
866 |
826 assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L); |
867 assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L); |
|
868 |
827 assertTrue((s = lock.tryOptimisticRead()) != 0L); |
869 assertTrue((s = lock.tryOptimisticRead()) != 0L); |
828 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
870 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
|
871 assertTrue(lock.isWriteLocked()); |
829 lock.unlockWrite(p); |
872 lock.unlockWrite(p); |
|
873 |
830 assertTrue((s = lock.writeLock()) != 0L); |
874 assertTrue((s = lock.writeLock()) != 0L); |
|
875 assertEquals(s, lock.tryConvertToWriteLock(s)); |
|
876 assertTrue(lock.validate(s)); |
|
877 assertTrue(lock.isWriteLocked()); |
|
878 lock.unlockWrite(s); |
|
879 |
|
880 assertTrue((s = lock.readLock()) != 0L); |
|
881 assertTrue(lock.validate(s)); |
831 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
882 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
832 assertTrue(lock.validate(p)); |
883 assertTrue(lock.validate(p)); |
|
884 assertTrue(lock.isWriteLocked()); |
833 lock.unlockWrite(p); |
885 lock.unlockWrite(p); |
834 assertTrue((s = lock.readLock()) != 0L); |
886 |
|
887 assertTrue((s = lock.tryWriteLock()) != 0L); |
|
888 assertTrue(lock.validate(s)); |
|
889 assertEquals(s, lock.tryConvertToWriteLock(s)); |
|
890 assertTrue(lock.validate(s)); |
|
891 assertTrue(lock.isWriteLocked()); |
|
892 lock.unlockWrite(s); |
|
893 |
|
894 assertTrue((s = lock.tryReadLock()) != 0L); |
835 assertTrue(lock.validate(s)); |
895 assertTrue(lock.validate(s)); |
836 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
896 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
837 assertTrue(lock.validate(p)); |
897 assertTrue(lock.validate(p)); |
|
898 assertTrue(lock.isWriteLocked()); |
838 lock.unlockWrite(p); |
899 lock.unlockWrite(p); |
839 assertTrue((s = lock.tryWriteLock()) != 0L); |
900 |
840 assertTrue(lock.validate(s)); |
|
841 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
|
842 assertTrue(lock.validate(p)); |
|
843 lock.unlockWrite(p); |
|
844 assertTrue((s = lock.tryReadLock()) != 0L); |
|
845 assertTrue(lock.validate(s)); |
|
846 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
|
847 assertTrue(lock.validate(p)); |
|
848 lock.unlockWrite(p); |
|
849 assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); |
901 assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L); |
850 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
902 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
851 assertTrue(lock.validate(p)); |
903 assertTrue(lock.validate(p)); |
|
904 assertTrue(lock.isWriteLocked()); |
852 lock.unlockWrite(p); |
905 lock.unlockWrite(p); |
|
906 |
853 assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); |
907 assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L); |
854 assertTrue(lock.validate(s)); |
908 assertTrue(lock.validate(s)); |
855 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
909 assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L); |
856 assertTrue(lock.validate(p)); |
910 assertTrue(lock.validate(p)); |
|
911 assertTrue(lock.isWriteLocked()); |
857 lock.unlockWrite(p); |
912 lock.unlockWrite(p); |
858 } |
913 } |
859 |
914 |
860 /** |
915 /** |
861 * asWriteLock can be locked and unlocked |
916 * asWriteLock can be locked and unlocked |
901 lock.lock(); |
956 lock.lock(); |
902 lock.unlock(); |
957 lock.unlock(); |
903 assertTrue(lock.tryLock()); |
958 assertTrue(lock.tryLock()); |
904 } |
959 } |
905 |
960 |
|
961 /** |
|
962 * Lock.newCondition throws UnsupportedOperationException |
|
963 */ |
|
964 public void testLockViewsDoNotSupportConditions() { |
|
965 StampedLock sl = new StampedLock(); |
|
966 assertThrows(UnsupportedOperationException.class, |
|
967 () -> sl.asWriteLock().newCondition(), |
|
968 () -> sl.asReadLock().newCondition(), |
|
969 () -> sl.asReadWriteLock().writeLock().newCondition(), |
|
970 () -> sl.asReadWriteLock().readLock().newCondition()); |
|
971 } |
|
972 |
|
973 /** |
|
974 * Passing optimistic read stamps to unlock operations result in |
|
975 * IllegalMonitorStateException |
|
976 */ |
|
977 public void testCannotUnlockOptimisticReadStamps() { |
|
978 Runnable[] actions = { |
|
979 () -> { |
|
980 StampedLock sl = new StampedLock(); |
|
981 long stamp = sl.tryOptimisticRead(); |
|
982 assertTrue(stamp != 0); |
|
983 sl.unlockRead(stamp); |
|
984 }, |
|
985 () -> { |
|
986 StampedLock sl = new StampedLock(); |
|
987 long stamp = sl.tryOptimisticRead(); |
|
988 sl.unlock(stamp); |
|
989 }, |
|
990 |
|
991 () -> { |
|
992 StampedLock sl = new StampedLock(); |
|
993 long stamp = sl.tryOptimisticRead(); |
|
994 sl.writeLock(); |
|
995 sl.unlock(stamp); |
|
996 }, |
|
997 () -> { |
|
998 StampedLock sl = new StampedLock(); |
|
999 long stamp = sl.tryOptimisticRead(); |
|
1000 sl.readLock(); |
|
1001 sl.unlockRead(stamp); |
|
1002 }, |
|
1003 () -> { |
|
1004 StampedLock sl = new StampedLock(); |
|
1005 long stamp = sl.tryOptimisticRead(); |
|
1006 sl.readLock(); |
|
1007 sl.unlock(stamp); |
|
1008 }, |
|
1009 |
|
1010 () -> { |
|
1011 StampedLock sl = new StampedLock(); |
|
1012 long stamp = sl.tryConvertToOptimisticRead(sl.writeLock()); |
|
1013 assertTrue(stamp != 0); |
|
1014 sl.writeLock(); |
|
1015 sl.unlockWrite(stamp); |
|
1016 }, |
|
1017 () -> { |
|
1018 StampedLock sl = new StampedLock(); |
|
1019 long stamp = sl.tryConvertToOptimisticRead(sl.writeLock()); |
|
1020 sl.writeLock(); |
|
1021 sl.unlock(stamp); |
|
1022 }, |
|
1023 () -> { |
|
1024 StampedLock sl = new StampedLock(); |
|
1025 long stamp = sl.tryConvertToOptimisticRead(sl.writeLock()); |
|
1026 sl.readLock(); |
|
1027 sl.unlockRead(stamp); |
|
1028 }, |
|
1029 () -> { |
|
1030 StampedLock sl = new StampedLock(); |
|
1031 long stamp = sl.tryConvertToOptimisticRead(sl.writeLock()); |
|
1032 sl.readLock(); |
|
1033 sl.unlock(stamp); |
|
1034 }, |
|
1035 |
|
1036 () -> { |
|
1037 StampedLock sl = new StampedLock(); |
|
1038 long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); |
|
1039 assertTrue(stamp != 0); |
|
1040 sl.writeLock(); |
|
1041 sl.unlockWrite(stamp); |
|
1042 }, |
|
1043 () -> { |
|
1044 StampedLock sl = new StampedLock(); |
|
1045 long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); |
|
1046 sl.writeLock(); |
|
1047 sl.unlock(stamp); |
|
1048 }, |
|
1049 () -> { |
|
1050 StampedLock sl = new StampedLock(); |
|
1051 long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); |
|
1052 sl.readLock(); |
|
1053 sl.unlockRead(stamp); |
|
1054 }, |
|
1055 () -> { |
|
1056 StampedLock sl = new StampedLock(); |
|
1057 sl.readLock(); |
|
1058 long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); |
|
1059 assertTrue(stamp != 0); |
|
1060 sl.readLock(); |
|
1061 sl.unlockRead(stamp); |
|
1062 }, |
|
1063 () -> { |
|
1064 StampedLock sl = new StampedLock(); |
|
1065 long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); |
|
1066 sl.readLock(); |
|
1067 sl.unlock(stamp); |
|
1068 }, |
|
1069 () -> { |
|
1070 StampedLock sl = new StampedLock(); |
|
1071 sl.readLock(); |
|
1072 long stamp = sl.tryConvertToOptimisticRead(sl.readLock()); |
|
1073 sl.readLock(); |
|
1074 sl.unlock(stamp); |
|
1075 }, |
|
1076 }; |
|
1077 |
|
1078 assertThrows(IllegalMonitorStateException.class, actions); |
|
1079 } |
|
1080 |
906 } |
1081 } |