import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {

    public static void main(String[] args) throws InterruptedException {
        // Создаем CountDownLatch для трех потоков
        CountDownLatch latch = new CountDownLatch(3);

        // Запускаем три потокa
        for (int i = 0; i < 3; i++) {
            new Thread(new Task(latch)).start();
        }

        // Основной поток ждет, пока все потоки завершатся
        latch.await();
        System.out.println("Все задачи завершены, продолжение работы основного потока.");
    }
}

class Task implements Runnable {
    private final CountDownLatch latch;

    public Task(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            // Симуляция работы
            Thread.sleep((long) (Math.random() * 1000));
            System.out.println("Задача завершена: " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // Уменьшаем счетчик
            latch.countDown();
        }
    }
}

  class Person implements Comparable<Person> {
      private String name;
      private int age;

      public Person(String name, int age) {
          this.name = name;
          this.age = age;
      }

      public int getAge() {
          return age;
      }

      @Override
      public int compareTo(Person other) {
          return Integer.compare(this.age, other.age); // Сравнение по возрасту
      }
  }

  import java.util.Comparator;

  class NameComparator implements Comparator<Person> {
      @Override
      public int compare(Person p1, Person p2) {
          return p1.name.compareTo(p2.name); // Сравнение по имени
      }
  }

  List<Person> people = Arrays.asList(new Person("Alice", 30), new Person("Bob", 25));
  Collections.sort(people); // Сортировка по возрасту с использованием Comparable

  List<Person> people = Arrays.asList(new Person("Alice", 30), new Person("Bob", 25));
  Collections.sort(people, new NameComparator()); // Сортировка по имени с использованием Comparator

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private String email;
}

import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {
    private final List<User> users = new ArrayList<>();

    @GetMapping
    public List<User> getAllUsers() {
        return users; // Получение всех пользователей
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        users.add(user); // Создание нового пользователя
        return user;
    }
}

GET /api/users

POST /api/users
Content-Type: application/json

{
    "id": 1,
    "name": "John Doe",
    "email": "john.doe@example.com"
}

   ExecutorService executor = Executors.newFixedThreadPool(5);

   ExecutorService executor = Executors.newCachedThreadPool();

   ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);

   <dependency>
       <groupId>log4j</groupId>
       <artifactId>log4j</artifactId>
       <version>1.2.17</version>
   </dependency>

   log4j.rootLogger=DEBUG, FILE

   log4j.appender.FILE=org.apache.log4j.FileAppender
   log4j.appender.FILE.File=application.log
   log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
   log4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1} - %m%n

   import org.apache.log4j.Logger;

   public class Log4jExample {
       static Logger logger = Logger.getLogger(Log4jExample.class);

       public static void main(String[] args) {
           logger.info("Информационное сообщение");
           logger.error("Ошибка!", new Exception("Пример исключения"));
       }
   }

   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-api</artifactId>
       <version>1.7.30</version>
   </dependency>
   <dependency>
       <groupId>org.slf4j</groupId>
       <artifactId>slf4j-log4j12</artifactId>
       <version>1.7.30</version>
   </dependency>

   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;

   public class Slf4jExample {
       private static final Logger logger = LoggerFactory.getLogger(Slf4jExample.class);

       public static void main(String[] args) {
           logger.info("Информационное сообщение с SLF4J");
           logger.error("Ошибка!", new Exception("Пример исключения"));
       }
   }

ExecutorService executor = Executors.newFixedThreadPool(5);

for (int i = 0; i < 10; i++) {
    final int taskId = i;
    executor.submit(() -> {
        System.out.println("Задача " + taskId + " выполняется в: " + Thread.currentThread().getName());
        // Имитация длительной задачи
        try {
            Thread.sleep(1000); // Задержка на 1 секунду
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Задача " + taskId + " завершена в: " + Thread.currentThread().getName());
    });
}

executor.shutdown(); // Ждем завершения всех задач

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@interface Inject {}

class Service {
    public void serve() {
        System.out.println("Service is working!");
    }
}

class Client {
    @Inject
    private Service service;

    public void doSomething() {
        service.serve();
    }
}

import java.lang.reflect.Field;

class DIContainer {
    public static void inject(Object obj) {
        Class<?> clazz = obj.getClass();
        
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(Inject.class)) {
                try {
                    field.setAccessible(true); // Делаем поле доступным
                    Object dependency = field.getType().getDeclaredConstructor().newInstance(); // Создаем экземпляр зависимости
                    field.set(obj, dependency); // Внедряем зависимость
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Client client = new Client();
        DIContainer.inject(client); // Внедряем зависимости

        client.doSomething(); // Вывод: Service is working!
    }
}