Кода -копия выглядит следующим образом:
пакет com.yao;
импортировать java.util.concurrent.executorservice;
импортировать java.util.concurrent.executors;
импортировать java.util.concurrent.future;
импортировать java.util.concurrent.locks.lock;
Import java.util.concurrent.locks.readwritelock;
Import java.util.concurrent.locks.reentrantlock;
Импорт java.util.concurrent.locks.reentrantreadwritelock;
/**
* Шкафчики
* Важная концепция в многопоточном программировании-блокировка.
* При выполнении транзакционных операций необходимо заблокировать общий ресурс, что гарантирует, что только один поток может работать на ресурсе при выполнении транзакционных операций.
* Это обеспечивает целостность данных. До 5.0 функция блокировки была реализована с помощью синхронизированного ключевого слова.
*/
открытый класс шкафчики {
/**
* Проверьте использование блокировки. Использование блокировки в методе может избежать использования синхронизированного ключевого слова.
*/
public Static Class LockTest {
Lock lock = new Reentrantlock (); // lock
двойное значение = 0d; // Значение
int addTime = 0;
/**
* Увеличьте значение значения.
* Таким образом, метод должен быть синхронизирован, предыдущая практика состояла в том, чтобы использовать синхронизированное ключевое слово в объявлении метода.
*/
public void AddValue (Double V) {
lock.lock (); // получить блокировку
System.out.println ("Locktest to AddValue:" + V + ""
+ System.currentTimeMiLsis ());
пытаться {
Thread.sleep (1000);
} catch (прерванная экспрессия e) {
}
this.value += v;
this.addtimes ++;
lock.unlock (); // Отпустите блокировку
}
public double getValue () {
вернуть это.
}
}
public static void testlocktest () бросает исключение {
final locktest locktest = new LockTest ();
// Создать новую задачу 1 и вызовать метод AddValue LockTest
Runnable Task1 = new Runnable () {
public void run () {
locktest.addvalue (55,55);
}
};
// Создать новую задачу 2 и вызовать метод GetValue от LockTest
Runnable task2 = new Runnable () {
public void run () {
System.out.println ("value:" + locktest.getValue ());
}
};
// Создать новую службу выполнения задач
Executorservice cachedservice = executors.newcachedthreadpool ();
Будущее = null;
// выполнить задачу 1 три раза одновременно.
для (int i = 0; i <3; i ++) {
future = cachedservice.submit (task1);
}
// ждать выполнения последней задачи 1
future.get ();
// снова выполнить задачу 2, чтобы вывести результат
future = cachedservice.submit (task2);
// после ожидания выполнения задачи 2, закройте службу выполнения задачи
future.get ();
cachedservice.shutdownnow ();
}
/**
* ReadWriteLock имеет два встроенных замка, один-это замок для чтения, а другой-письменный замок.
* Несколько потоков могут получить блокировки чтения одновременно, но только один поток может получить записанные блокировки.
* И после того, как написанная блокировка заблокирована, ни один поток не может получить блокировку. Методы, предоставленные ReadWriteLock:
* readlock (): возвращает блокировку чтения
* WriteLock (): возвращает письменную блокировку, этот замок эксклюзивный.
* ReadWriteLockTest очень подходит для обработки операций чтения и записи аналогичных файлов.
* Вы можете прочитать одновременно при чтении, но вы не можете писать;
*/
Public Static Class ReadWritElockTest {
// Замок
Readwritelock lock = new ReenterTreadWriteLock ();
// Ценить
двойное значение = 0d;
int addTime = 0;
/**
* Увеличивайте значение значения и не позволяйте нескольким потокам вводить метод одновременно.
*/
public void AddValue (Double V) {
// Получить writeLock и lock
Lock writeLock = lock.writelock ();
writeLock.lock ();
System.out.println ("readwritelocktest to addvalue:" + v + ""
+ System.currentTimeMiLsis ());
пытаться {
Thread.sleep (1000);
} catch (прерванная экспрессия e) {
}
пытаться {
// Делать писательскую работу
this.value += v;
this.addtimes ++;
} окончательно {
// выпустить Lock Lock WriteLock
writeLock.unlock ();
}
}
/**
* Получите информацию. Когда поток вызывает метод AddValue, информация, полученная GetInfo, может быть неверной.
* Следовательно, также необходимо убедиться, что при вызове метода ни один метод не вызывает метод AddValue.
*/
public String getInfo () {
// Получите чтение и блокировку
Lock readlock = lock.readlock ();
readlock.lock ();
System.out.println ("readwritelocktest to GetInfo"
+ System.currentTimeMiLsis ());
пытаться {
Thread.sleep (1000);
} catch (прерванная экспрессия e) {
}
пытаться {
// Делать работу по чтению
вернуть это. Value + ":" + this.addtimes;
} окончательно {
// Выпуск Readlock
readlock.unlock ();
}
}
}
public static void testreadWriteLockTest () бросает исключение {
final ReadWriteLockTest ReadWritElockTest = new ReadWritElockTest ();
// Создать новую задачу 1 и вызовать метод AddValue LockTest
Runnable Task_1 = new Runnable () {
public void run () {
readwritelocktest.addvalue (55,55);
}
};
// Создать новую задачу 2 и вызовать метод GetValue от LockTest
Runnable task_2 = new Runnable () {
public void run () {
System.out.println ("info:" + readwriteLocktest.getInfo ());
}
};
// Создать новую службу выполнения задач
Executorservice cachedservice_1 = executors.newcachedthreadpool ();
Future Future_1 = NULL;
// выполнять 5 задач одновременно, из которых первые 2 задачи представляют собой Task_1, а последние две задачи - Task_2
для (int i = 0; i <2; i ++) {
future_1 = cachedservice_1.submit (task_1);
}
для (int i = 0; i <2; i ++) {
future_1 = cachedservice_1.submit (task_2);
}
// последняя задача - task_1
future_1 = cachedservice_1.submit (task_1);
// порядок выполнения этих 5 задач должен быть:
// Первый Task_1 выполняется сначала, а второй Task_1 выполняется снова;
// Затем два Task_2 выполняются одновременно;
// Поскольку их можно прочитать одновременно, они выполняются одновременно
// Последняя задача_1 выполняется снова. Это потому, что вы не можете писать при чтении, поэтому вы должны подождать, пока чтение не закончится, прежде чем вы сможете написать.
// ждать выполнения последнего задачи_2
future_1.get ();
cachedservice_1.shutdownnow ();
}
public static void main (string [] args) бросает исключение {
Lockers.testlocktest ();
System.out.println ("---------------------");
Lockers.testreadWriteLockTest ();
}
}