Java for Beginner

Варианты ответа:

Anonymous Quiz

banana date

6 voters146 viewsДен, 08:34

Java for Beginner

Что выведет код?

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>(Arrays.asList("apple", "banana", "cherry", "date"));
        List<String> list = new ArrayList<>(set);
        
        Collections.sort(list, new CustomComparator());
        Queue<String> queue = new LinkedList<>(list);

        System.out.println(queue.poll() + " " + queue.peek());
    }
}

class CustomComparator implements Comparator<String> {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
}

#Tasks

141 viewsДен, 08:35

Java for Beginner

Подписывайтесь на канал, мы знаем, что было в начале 😎

https://t.me/Java_for_beginner_dev

#Mems

142 viewsДен, 10:23

Java for Beginner

Please open Telegram to view this post

VIEW IN TELEGRAM

137 viewsДен, edited 11:43

Java for Beginner

Статические вложенные классы и примеры использования внутренних классов

Статические вложенные классы (Static Nested Classes)

Статические вложенные классы объявляются с ключевым словом static. Они похожи на обычные внутренние классы, но не имеют доступа к нестатическим членам внешнего класса. Они могут использоваться как самостоятельные классы.

public class OuterClass {
    private static String staticOuterField = "Static Outer Field";

    public static class StaticNestedClass {
        public void display() {
            System.out.println("Static outer field is: " + staticOuterField);
        }
    }

    public static void main(String[] args) {
        StaticNestedClass nested = new StaticNestedClass();
        nested.display();
    }
}

В этом примере StaticNestedClass является статическим вложенным классом и имеет доступ только к статическим полям внешнего класса OuterClass.

Использование обычных внутренних классов:

Обычные внутренние классы часто используются, когда необходимо логически сгруппировать класс внутри другого класса и когда внутренний класс должен иметь доступ к членам внешнего класса.

public class OuterClass {
    private String outerField = "Outer Field";

    public class InnerClass {
        public void display() {
            System.out.println("Outer field is: " + outerField);
        }
    }

    public void testInner() {
        InnerClass inner = new InnerClass();
        inner.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.testInner();
    }
}

Использование локальных внутренних классов:

Локальные внутренние классы полезны, когда вам нужен вспомогательный класс, который используется только внутри метода.

public class OuterClass {
    public void methodWithInnerClass() {
        class LocalInnerClass {
            void display() {
                System.out.println("This is a local inner class");
            }
        }
        
        LocalInnerClass localInner = new LocalInnerClass();
        localInner.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.methodWithInnerClass();
    }
}

Использование анонимных внутренних классов:

Анонимные внутренние классы часто используются для создания простых одноразовых объектов с переопределенными методами.

public class OuterClass {
    public void createAnonymousClass() {
        MyInterface anonymous = new MyInterface() {
            @Override
            public void myMethod() {
                System.out.println("Anonymous inner class method");
            }
        };
        anonymous.myMethod();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.createAnonymousClass();
    }
}

interface MyInterface {
    void myMethod();
}

Преимущества и недостатки внутренних классов

Преимущества:

Улучшение логической организации кода.
Упрощение доступа к членам внешнего класса.
Снижение количества классов верхнего уровня.

Недостатки:

Усложнение кода для начинающих программистов.
Потенциальные проблемы с производительностью из-за увеличения числа классов.

#Java #Training

145 viewsДен, 13:28

Java for Beginner

Лямбда-выражения

Лямбда-выражения, или просто "лямбды", были введены в Java 8 и представляют собой компактный способ представления анонимных функций. Они позволяют передавать поведение как параметр метода, что делает код более гибким и лаконичным.

Синтаксис лямбда-выражений

Лямбда-выражение состоит из параметров, стрелки (->) и тела. Существует несколько форм записи лямбда-выражений:

Без параметров:

() -> System.out.println("Hello, World!");

С одним параметром (скобки можно опустить):

x -> x * 2;

С несколькими параметрами:

(x, y) -> x + y;

С телом, состоящим из нескольких выражений:

(x, y) -> {
    int sum = x + y;
    return sum;
};

Использование лямбда-выражений

Лямбда-выражения чаще всего используются в сочетании с функциональными интерфейсами. Функциональный интерфейс — это интерфейс с единственным абстрактным методом (SAM — Single Abstract Method). Примеры таких интерфейсов включают Runnable, Callable, Comparator и интерфейсы из пакета java.util.function.

Пример использования лямбда-выражения с функциональным интерфейсом Runnable:

Runnable r = () -> System.out.println("Lambda Runnable");
new Thread(r).start();

Встроенные функциональные интерфейсы

Java предоставляет ряд встроенных функциональных интерфейсов в пакете java.util.function, которые можно использовать с лямбда-выражениями. Некоторые из них:

Predicate<T>: принимает один аргумент и возвращает логическое значение.

Predicate<String> isEmpty = s -> s.isEmpty();
System.out.println(isEmpty.test("")); // true

Consumer<T>: принимает один аргумент и не возвращает результат.

Consumer<String> printer = s -> System.out.println(s);
printer.accept("Hello, Consumer!");

Function<T, R>: принимает один аргумент и возвращает результат.

Function<Integer, String> intToString = num -> "Number: " + num;
System.out.println(intToString.apply(5)); // Number: 5

Supplier<T>: не принимает аргументов, но возвращает результат.

Supplier<Double> randomValue = () -> Math.random();
System.out.println(randomValue.get());

UnaryOperator<T>: принимает один аргумент и возвращает результат того же типа.

UnaryOperator<Integer> square = x -> x * x;
System.out.println(square.apply(5)); // 25

BinaryOperator<T>: принимает два аргумента и возвращает результат того же типа.

BinaryOperator<Integer> add = (x, y) -> x + y;
System.out.println(add.apply(2, 3)); // 5

#Java #Training #Medium

156 viewsДен, 05:16

Java for Beginner

Что выведет код?

public class ArithmeticExample {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 5;

        int result = (a * b / c) + (a % c * b) - (a - c);
        
        System.out.println(result);
    }
}

#Tasks

146 viewsДен, 08:23

Java for Beginner

Варианты ответа:

Anonymous Quiz

33%

67%

12 voters154 viewsДен, 08:28

Java for Beginner

Действительно, почему?🧐

https://t.me/Java_for_beginner_dev

#Mems

219 viewsДен, 10:04

Java for Beginner

Применение лямбда-выражений в коллекциях и Stream API

Лямбда-выражения и коллекции

Одним из самых мощных применений лямбда-выражений является их использование в коллекциях. С введением лямбд в Java 8, стандартные интерфейсы коллекций были расширены новыми методами, такими как forEach, removeIf, replaceAll и sort, которые принимают лямбда-выражения в качестве параметров.

Метод forEach:

List<String> list = Arrays.asList("a", "b", "c", "d");
list.forEach(element -> System.out.println(element));

Метод removeIf:

List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three", "four"));
list.removeIf(element -> element.length() > 3);
list.forEach(System.out::println); // one, two

Метод replaceAll:

List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three", "four"));
list.replaceAll(String::toUpperCase);
list.forEach(System.out::println); // ONE, TWO, THREE, FOUR

Метод sort:

List<String> list = new ArrayList<>(Arrays.asList("one", "two", "three", "four"));
list.sort((s1, s2) -> s1.compareTo(s2));
list.forEach(System.out::println); // four, one, three, two

Лямбда-выражения и Stream API

Stream API в Java 8 позволяет легко и эффективно работать с потоками данных, выполняя операции над элементами коллекций. Лямбда-выражения играют ключевую роль в использовании Stream API.

Создание Stream:

List<String> list = Arrays.asList("one", "two", "three", "four");
Stream<String> stream = list.stream();

Фильтрация (filter):

List<String> list = Arrays.asList("one", "two", "three", "four");
List<String> filteredList = list.stream()
                                 .filter(s -> s.startsWith("t"))
                                 .collect(Collectors.toList());
filteredList.forEach(System.out::println); // two, three

Преобразование (map):

List<String> list = Arrays.asList("one", "two", "three", "four");
List<Integer> lengths = list.stream()
                            .map(String::length)
                            .collect(Collectors.toList());
lengths.forEach(System.out::println); // 3, 3, 5, 4

Сортировка (sorted):

List<String> list = Arrays.asList("one", "two", "three", "four");
List<String> sortedList = list.stream()
                              .sorted()
                              .collect(Collectors.toList());
sortedList.forEach(System.out::println); // four, one, three, two

Агрегация (reduce):

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
                 .reduce(0, (a, b) -> a + b);
System.out.println(sum); // 15

Преимущества лямбда-выражений

Компактность и читабельность: Лямбда-выражения позволяют значительно сократить объем кода, особенно при работе с коллекциями и потоками.
Удобство использования: Лямбда-выражения упрощают передачу поведения как параметра и делают код более декларативным.
Функциональное программирование: Лямбда-выражения являются основой функционального программирования в Java, позволяя легко работать с функциями высшего порядка и композициями.

#Java #Training #Medium

169 viewsДен, 13:19

Java for Beginner

Введение в Stream API и основные методы создания стримов

Stream API, введенный в Java 8, предоставляет мощный способ работы с коллекциями данных. Stream представляет собой последовательность элементов, поддерживающую различные операции для создания желаемых результатов. Операции со стримами могут быть промежуточными (возвращающими другой стрим) и терминальными (возвращающими конечный результат).

Создание стримов

Из коллекций:

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

Из массивов:

String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

Из значений:

Stream<String> stream = Stream.of("a", "b", "c");

Из файлов:

try (Stream<String> stream = Files.lines(Paths.get("file.txt"))) {
    stream.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

Бесконечные стримы:

iterate:

Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(10);
stream.forEach(System.out::println);

generate:

Stream<Double> stream = Stream.generate(Math::random).limit(10);
stream.forEach(System.out::println);

Промежуточные методы Stream API

Промежуточные методы возвращают новый стрим, позволяя строить цепочки операций.

filter:

List<String> list = Arrays.asList("a", "ab", "abc", "abcd");
list.stream()
    .filter(s -> s.length() > 2)
    .forEach(System.out::println); // abc, abcd

map:

List<String> list = Arrays.asList("1", "2", "3");
list.stream()
    .map(Integer::parseInt)
    .forEach(System.out::println); // 1, 2, 3

flatMap:

List<List<String>> list = Arrays.asList(
    Arrays.asList("a", "b"),
    Arrays.asList("c", "d")
);
list.stream()
    .flatMap(Collection::stream)
    .forEach(System.out::println); // a, b, c, d

distinct:

List<String> list = Arrays.asList("a", "b", "a", "c", "b");
list.stream()
    .distinct()
    .forEach(System.out::println); // a, b, c

sorted:

Без компаратора:

List<String> list = Arrays.asList("c", "a", "b");
list.stream()
    .sorted()
    .forEach(System.out::println); // a, b, c

С компаратором:

List<String> list = Arrays.asList("c", "a", "b");
list.stream()
    .sorted(Comparator.reverseOrder())
    .forEach(System.out::println); // c, b, a

peek:

List<String> list = Arrays.asList("a", "b", "c");
list.stream()
    .peek(System.out::println)
    .map(String::toUpperCase)
    .forEach(System.out::println); // a, A, b, B, c, C

limit:

Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
stream.limit(5)
      .forEach(System.out::println); // 1, 2, 3, 4, 5

skip:

Stream<Integer> stream = Stream.iterate(1, n -> n + 1);
stream.skip(5)
      .limit(5)
      .forEach(System.out::println); // 6, 7, 8, 9, 10

#Java #Training #Stream #Medium

169 viewsДен, 05:32

Java for Beginner

Что выведет код?

public class ConcatenationExample {
    public static void main(String[] args) {
        int x = 5;
        int y = 10;
        String str1 = "Hello";
        String str2 = "World";

        String result = str1 + x + y + str2 + (x + y) + str1.length() + (x * y);
        
        System.out.println(result);
    }
}

#Tasks

158 viewsДен, 08:43

Java for Beginner

Варианты ответа:

Anonymous Quiz

79%

Hello510World15550

Hello510World15105Hello

14%

Hello510World1510150

Hello510World1510150Hello

14 voters156 viewsДен, 08:48

Java for Beginner

Почему не любят тестировщиков?🤪

https://t.me/Java_for_beginner_dev

#Mems

164 viewsДен, 10:24

Java for Beginner

Терминальные методы Stream API

Терминальные методы завершают цепочку операций со стримами, возвращая результат или выполняя действие.

forEach:

List<String> list = Arrays.asList("a", "b", "c");
list.stream()
    .forEach(System.out::println); // a, b, c

collect:

List<String> list = Arrays.asList("a", "b", "c");
List<String> result = list.stream()
                          .collect(Collectors.toList());

reduce:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream()
              .reduce(0, (a, b) -> a + b);

toArray:

List<String> list = Arrays.asList("a", "b", "c");
String[] array = list.stream()
                     .toArray(String[]::new);

findFirst:

List<String> list = Arrays.asList("a", "b", "c");
Optional<String> first = list.stream()
                             .findFirst();

findAny:

List<String> list = Arrays.asList("a", "b", "c");
Optional<String> any = list.stream()
                           .findAny();

count:

List<String> list = Arrays.asList("a", "b", "c");
long count = list.stream()
                 .count();

anyMatch:

List<String> list = Arrays.asList("a", "b", "c");
boolean anyMatch = list.stream()
                       .anyMatch(s -> s.equals("a"));

allMatch:

List<String> list = Arrays.asList("a", "b", "c");
boolean allMatch = list.stream()
                       .allMatch(s -> s.length() == 1);

noneMatch:

List<String> list = Arrays.asList("a", "b", "c");
boolean noneMatch = list.stream()
                        .noneMatch(s -> s.equals("d"));

Продвинутые методы и примеры использования Stream API

groupingBy:

List<String> list = Arrays.asList("a", "ab", "abc", "abcd");
Map<Integer, List<String>> groupedByLength = list.stream()
                                                 .collect(Collectors.groupingBy(String::length));

partitioningBy:

List<String> list = Arrays.asList("a", "ab", "abc", "abcd");
Map<Boolean, List<String>> partitionedByLength = list.stream()
                                                     .collect(Collectors.partitioningBy(s -> s.length() > 2));

mapping:

List<String> list = Arrays.asList("a", "ab", "abc", "abcd");
List<Integer> lengths = list.stream()
                            .collect(Collectors.mapping(String::length, Collectors.toList()));

joining:

List<String> list = Arrays.asList("a", "b", "c");
String joined = list.stream()
                    .collect(Collectors.joining(", "));

Примеры использования Stream API

Фильтрация и преобразование списка строк:

List<String> list = Arrays.asList("apple", "banana", "cherry", "date");
List<String> result = list.stream()
                          .filter(s -> s.startsWith("a"))
                          .map(String::toUpperCase)
                          .collect(Collectors.toList());

Группировка чисел по четности:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Map<Boolean, List<Integer>> evenOddMap = numbers.stream()
                                                .collect(Collectors.partitioningBy(n -> n % 2 == 0));

Подсчет элементов в списке:

List<String> list = Arrays.asList("a", "b", "c", "a", "b", "c");
Map<String, Long> frequencyMap = list.stream()
                                     .collect(Collectors.groupingBy(s -> s, Collectors.counting()));

Нахождение максимального значения в списке:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> maxNumber = numbers.stream()
                                     .max(Integer::compare);

#Java #Training #Stream #Medium

158 viewsДен, 13:38

Java for Beginner

Многопоточность

Многопоточность — это способность программы выполнять несколько потоков одновременно. В Java каждый поток представляет собой отдельную линию выполнения в приложении. Многопоточность позволяет эффективно использовать ресурсы многоядерных процессоров, повышая производительность и отзывчивость программ.

Параллелизм и конкурентность

Параллелизм: выполнение нескольких задач одновременно, например, на многоядерных процессорах.
Конкурентность: выполнение нескольких задач чередованием, для создания иллюзии одновременного выполнения на одноядерных процессорах.

Основные понятия многопоточности

Поток (Thread): наименьшая единица выполнения. Каждый поток выполняет свою задачу независимо.
Процесс: программа, выполняющаяся в отдельной среде. Каждый процесс может содержать несколько потоков.

Создание потоков

В Java создание потоков может быть реализовано двумя способами: наследованием класса Thread и реализацией интерфейса Runnable.

Наследование класса Thread

Создание класса, наследующего Thread:

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("MyThread is running");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // Запуск потока
    }
}

Реализация интерфейса Runnable

Создание класса, реализующего Runnable:

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("MyRunnable is running");
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start(); // Запуск потока
    }
}

Методы класса Thread

start(): запускает поток, вызывая метод run().
run(): содержит код, который выполнится в новом потоке.
sleep(long millis): приостанавливает выполнение потока на заданное количество миллисекунд.

public class MyThread extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(1000); // Поток спит 1 секунду
            System.out.println("Thread woke up");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

join(): ожидает завершения выполнения потока.

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running");
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
        try {
            thread.join(); // Ожидание завершения потока
            System.out.println("Thread has finished");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

isAlive(): возвращает true, если поток выполняется, иначе false.

MyThread thread = new MyThread();
thread.start();
System.out.println(thread.isAlive()); // true, если поток выполняется

Приоритеты потоков

Каждый поток в Java имеет приоритет, который влияет на порядок планирования потоков. Приоритеты варьируются от Thread.MIN_PRIORITY (1) до Thread.MAX_PRIORITY (10). Поток с более высоким приоритетом будет запланирован раньше, чем поток с более низким приоритетом.

public class MyThread extends Thread {
    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(getName() + " is running");
    }

    public static void main(String[] args) {
        MyThread thread1 = new MyThread("Thread 1");
        MyThread thread2 = new MyThread("Thread 2");

        thread1.setPriority(Thread.MIN_PRIORITY);
        thread2.setPriority(Thread.MAX_PRIORITY);

        thread1.start();
        thread2.start();
    }
}

#Java #Training #Multithreading #Medium

144 viewsДен, 05:17

Java for Beginner

Что выведет код?

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("apple");
        set.add("banana");
        set.add("apple");
        set.add("cherry");
        set.add(null);
        set.add("banana");

        int result = set.size() + (set.contains(null) ? 1 : 0) + (set.contains("apple") ? 1 : 0);
        
        System.out.println(result);
    }
}

#Tasks

139 viewsДен, 08:28

Java for Beginner

Варианты ответа:

Anonymous Quiz

10%

80%

10%

10 voters139 viewsДен, 08:33

Java for Beginner

Если одиноко, вставь autoplay в свою страницу и жди гостей🫣

https://t.me/Java_for_beginner_dev

#Mems

160 viewsДен, 10:09

Java for Beginner

Использование synchronized в многопоточности

Ключевое слово synchronized в Java используется для управления доступом к общим ресурсам несколькими потоками. Оно обеспечивает, что только один поток может выполнить синхронизированный блок или метод в определенный момент времени, предотвращая состояние гонки и обеспечивая корректное выполнение многопоточных программ.

Синхронизированные методы

Синхронизированные методы автоматически захватывают монитор объекта, на котором они вызываются. Это гарантирует, что только один поток может выполнить синхронизированный метод объекта одновременно.

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + counter.getCount()); // 2000
    }
}

Синхронизированные блоки

Синхронизированные блоки позволяют синхронизировать доступ к общим ресурсам более гибко, чем синхронизированные методы. Они позволяют выбрать объект для захвата монитора и синхронизировать только часть кода, что может повысить производительность.

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + counter.getCount()); // 2000
    }
}

Синхронизация по классу

Синхронизация по классу используется для статических методов и блоков. В этом случае захватывается монитор класса, а не объекта.

public class StaticCounter {
    private static int count = 0;

    public static synchronized void increment() {
        count++;
    }

    public static synchronized int getCount() {
        return count;
    }
}

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            StaticCounter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + StaticCounter.getCount()); // 2000
    }
}

132 viewsДен, 12:35

Java for Beginner

Mutex и Lock

В Java Lock предоставляется в пакете java.util.concurrent.locks. Это более мощный инструмент синхронизации, чем synchronized, предлагающий больше возможностей, таких как попытка захвата блокировки без ожидания, прерывание во время ожидания блокировки и использование условных переменных.

Интерфейс Lock

Интерфейс Lock предоставляет основные методы для управления блокировкой.

lock(): Захватывает блокировку.
unlock(): Освобождает блокировку.
tryLock(): Попытка захвата блокировки без ожидания.
lockInterruptibly(): Захват блокировки с возможностью прерывания.

Пример использования ReentrantLock

ReentrantLock — это реализация интерфейса Lock, позволяющая потоку захватить блокировку несколько раз.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + counter.getCount()); // 2000
    }
}

Использование tryLock()

Метод tryLock() пытается захватить блокировку немедленно, возвращая true, если это удалось, и false в противном случае.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        if (lock.tryLock()) {
            try {
                count++;
            } finally {
                lock.unlock();
            }
        } else {
            System.out.println("Unable to lock");
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

public class MyThread extends Thread {
    private Counter counter;

    public MyThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        MyThread thread1 = new MyThread(counter);
        MyThread thread2 = new MyThread(counter);
        
        thread1.start();
        thread2.start();
        
        thread1.join();
        thread2.join();
        
        System.out.println("Final count: " + counter.getCount()); // 2000
    }
}

136 viewsДен, 12:53

About

Blog

Apps

Platform