Як я можу використовувати ConcurrentLinkedQueueJava?
Використовуючи це LinkedQueue, чи потрібно мені турбуватися про паралельність у черзі? Або мені просто потрібно визначити два способи (один для отримання елементів зі списку та інший для додавання елементів до списку)?
Примітка: очевидно, що ці два методи мають бути синхронізовані. Правильно?

EDIT: Я намагаюся зробити так: у мене є клас (на Java) з одним методом для отримання елементів із черги, а інший клас з одним методом для додавання елементів до черги. Елементи, додані та отримані зі списку, є об'єктами мого власного класу.

Ще одне питання: чи потрібно це робити методом видалення:

while (queue.size() == 0){ 
  wait(); 
  queue.poll();
}

У мене є лише один споживач і один виробник.

Ні, методи не потрібно синхронізувати, і вам не потрібно визначати будь-які методи; вони вже знаходяться в ConcurrentLinkedQueue, просто використовуйте їх. ConcurrentLinkedQueue виконує всі функції блокування та інші необхідні операції; ваш виробник додає дані до черги, а ваші споживачі опитують їх.

Спочатку створіть свою чергу:

Queue<YourObject> queue = new ConcurrentLinkedQueue<YourObject>();

Тепер, де б ви не створювали об'єкти виробника / споживача, перейдіть до черги, щоб вони десь розмістили свої об’єкти (ви можете використовувати для цього сетер, але я вважаю за краще робити подібні речі в конструкторі):

YourProducer producer = new YourProducer(queue);

і:

YourConsumer consumer = new YourConsumer(queue);

і додайте до нього речі у своєму продюсері:

queue.offer(myObject);

і винесіть речі у вашого споживача (якщо черга порожня, poll () поверне нуль, тому перевірте це):

YourObject myObject = queue.poll();

Для отримання додаткової інформації див . Javadoc

Редагувати:

Якщо вам потрібно заблокувати очікування, коли черга не буде порожньою, ви, ймовірно, хочете скористатися LinkedBlockingQueue і скористатися методом take (). Однак LinkedBlockingQueue має максимальну ємність (за замовчуванням Integer.MAX_VALUE, що перевищує два мільярди), і, отже, може бути або не відповідати вашим обставинам.

Якщо у вас є лише один потік, який розміщує речі в черзі, а інший потік виводить речі з черги, ConcurrentLinkedQueue, ймовірно, надмірний. Це більше для того, коли у вас можуть бути сотні або навіть тисячі потоків, що одночасно отримують доступ до черги. Можливо, ваші потреби будуть задоволені, використовуючи:

Queue<YourObject> queue = Collections.synchronizedList(new LinkedList<YourObject>());

Плюсом цього є те, що він блокується на екземплярі (черзі), тому ви можете синхронізуватися в черзі, щоб забезпечити атомність складених операцій (як пояснив Джаред). Ви НЕ МОЖЕТЕ зробити це за допомогою ConcurrentLinkedQueue, оскільки всі операції виконуються БЕЗ блокування екземпляра (за допомогою змінних java.util.concurrent.atomic). ЦЕ НЕ буде потрібно робити, якщо ви хочете заблокувати, поки черга порожня, тому що опитування () просто поверне нуль, поки черга порожня, а опитування () - атомне. Перевірте, чи опитування () повертає нуль. Якщо це так, зачекайте (), тоді спробуйте ще раз. Не потрібно блокувати.

Нарешті:

Чесно кажучи, я просто скористався LinkedBlockingQueue. Це все ще надмірно для вашої програми, але, ймовірно, це буде працювати нормально. Якщо він недостатньо продуктивний (ПРОФІЛЬ!), Ви завжди можете спробувати щось інше, і це означає, що вам не доведеться мати справу з БУДЬ-ЯКИМИ синхронізованими матеріалами:

BlockingQueue<YourObject> queue = new LinkedBlockingQueue<YourObject>();

queue.put(myObject); // Blocks until queue isn't full.

YourObject myObject = queue.take(); // Blocks until queue isn't empty.

Все інше те саме. Покладіть, ймовірно , не буде блокуватись, оскільки ви, ймовірно, не поставите два мільярди об’єктів у чергу.

Це багато в чому дублікат іншого питання .

Ось розділ цієї відповіді, що стосується цього питання:

Чи потрібно робити власну синхронізацію, якщо я використовую java.util.ConcurrentLinkedQueue?

Атомні операції над паралельними колекціями синхронізовані для вас. Іншими словами, кожен окремий дзвінок у чергу гарантується безпекою потоку без будь-яких дій з вашого боку. Те, що не гарантується безпекою потоків, - це будь-які операції, що виконуються над колекцією, які не є атомними.

Наприклад, це безпечна нитка без будь-яких дій з вашого боку:

queue.add(obj);

або

queue.poll(obj);

Однак; неатомарні дзвінки до черги не є автоматично безпечними для потоків. Наприклад, такі операції не є автоматично безпечними для потоків:

if(!queue.isEmpty()) {
   queue.poll(obj);
}

Останнє не є безпечним для потоків, оскільки дуже можливо, що між тим часом, коли викликається порожній і викликається опитуванням часу, інші потоки додаватимуть чи видалятимуть елементи з черги. Надійний спосіб виконати це так:

synchronized(queue) {
    if(!queue.isEmpty()) {
       queue.poll(obj);
    }
}

Знову ж таки ... атомарні виклики до черги автоматично безпечні для потоку. Неатомні дзвінки ні.

Використовуйте опитування, щоб отримати перший елемент, і додайте, щоб додати новий останній елемент. Це все, ніяка синхронізація чи щось інше.

Це, мабуть, саме те, що ви шукаєте з точки зору безпеки потоків та "гарності", намагаючись використати все в черзі:

for (YourObject obj = queue.poll(); obj != null; obj = queue.poll()) {
}

Це гарантуватиме, що ви вийдете, коли черга порожня, і продовжуватимете виводити об’єкти з неї, доки вона не порожня.

ConcurentLinkedQueue - це дуже ефективна реалізація без очікування / блокування (див. Javadoc для довідки), тому не тільки вам не потрібно синхронізуватись, але черга нічого не блокує, таким чином, вона практично така ж швидка, як не синхронізована (не потік безпечний) один.

Просто використовуйте його, як і колись колекція, що не є одночасною. Класи Concurrent [Collection] обгортають звичайні колекції так, що вам не доведеться думати про синхронізацію доступу.

Редагувати: ConcurrentLinkedList насправді не просто обгортка, а скоріше краща паралельна реалізація. Так чи інакше, вам не доведеться турбуватися про синхронізацію.