BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

INSERT INTO transactions (from_account, to_account, amount) VALUES (1, 2, 100);

COMMIT;
Если любая из этих операций не выполняется, все изменения откатываются.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class TransactionalService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void performTransactionalOperation() {
        TransactionDefinition def = new DefaultTransactionDefinition();
        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            // Ваши операции с базой данных
            performDatabaseOperation1();
            performDatabaseOperation2();

            // Подтверждение транзакции
            transactionManager.commit(status);
        } catch (Exception e) {
            // Откат транзакции в случае ошибки
            transactionManager.rollback(status);
            throw e;
        }
    }

    private void performDatabaseOperation1() {
        // Код операции 1
    }

    private void performDatabaseOperation2() {
        // Код операции 2
    }
}
Этот метод предоставляет полный контроль над транзакциями, но делает код более сложным.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        // Семафор с 2 разрешениями
        Semaphore semaphore = new Semaphore(2);

        // Пул из 5 потоков
        ExecutorService executor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            executor.submit(() -> {
                try {
                    System.out.println("Thread " + threadId + " is waiting for permit...");
                    semaphore.acquire(); // Получаем разрешение
                    System.out.println("Thread " + threadId + " acquired permit.");
                    Thread.sleep(2000); // Имитируем использование ресурса
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    System.out.println("Thread " + threadId + " released permit.");
                    semaphore.release(); // Освобождаем разрешение
                }
            });
        }

        executor.shutdown();
    }
}

import java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
    public static void main(String[] args) throws InterruptedException {
        // Создаем CountDownLatch с начальным значением 3
        CountDownLatch latch = new CountDownLatch(3);

        // Потоки, выполняющие задачи
        Runnable task = () -> {
            System.out.println(Thread.currentThread().getName() + " is working...");
            try {
                Thread.sleep(1000); // Имитация работы
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println(Thread.currentThread().getName() + " finished.");
            latch.countDown(); // Уменьшаем значение счетчика
        };

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

        System.out.println("Main thread is waiting for tasks to finish...");
        latch.await(); // Ждем, пока счетчик не станет равен 0
        System.out.println("All tasks are finished. Main thread resumes.");
    }
}

Semaphore semaphore = new Semaphore(10); // Максимум 10 соединений

// Каждый поток пытается установить соединение
Runnable connectTask = () -> {
    try {
        semaphore.acquire();
        System.out.println("Connection established by " + Thread.currentThread().getName());
        Thread.sleep(2000); // Используем соединение
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        System.out.println("Connection released by " + Thread.currentThread().getName());
        semaphore.release();
    }
};

CountDownLatch latch = new CountDownLatch(3);

Runnable loadData = () -> {
    try {
        System.out.println(Thread.currentThread().getName() + " loading data...");
        Thread.sleep(1000);
        latch.countDown();
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
};

new Thread(loadData).start();
new Thread(loadData).start();
new Thread(loadData).start();

latch.await();
System.out.println("All data loaded. Proceeding to next step.");

public class Task221124_1 {
    public static void main(String[] args) {
        int[] arr = {3, 5, 7, 9, 11};
        int result = modifyArray(arr);
        System.out.println(result);
        System.out.println(arr[1]);
    }

    public static int modifyArray(int[] array) {
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] % 2 == 0 ? array[i] / 2 : array[i] * 2;
            sum += array[i];
        }
        return sum;
    }
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class PaymentService {

    @Transactional
    public void transferMoney(Long fromAccountId, Long toAccountId, double amount) {
        // Операции с базой данных
        debitAccount(fromAccountId, amount);
        creditAccount(toAccountId, amount);
    }

    private void debitAccount(Long accountId, double amount) {
        // Логика снятия средств
    }

    private void creditAccount(Long accountId, double amount) {
        // Логика зачисления средств
    }
}
В этом примере все операции внутри метода transferMoney выполняются в одной транзакции. Если любая операция завершится сбоем, все изменения будут откатаны.

@Transactional(
    propagation = Propagation.REQUIRES_NEW,
    isolation = Isolation.SERIALIZABLE,
    timeout = 30,
    rollbackFor = {RuntimeException.class},
    readOnly = false
)
public void processTransaction() {
    // Логика транзакции
}

@Transactional(rollbackFor = Exception.class)
public void updateDatabase() throws Exception {
    // Если возникает Exception, транзакция будет откатана
}

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Transactional
public class OrderService {

    public void createOrder() {
        // Операции в транзакции
    }

    public void cancelOrder() {
        // Операции в транзакции
    }
}

@Service
public class ExampleService {

    @Transactional
    public void method1() {
        method2(); // method2 вызван напрямую, @Transactional не применяется
    }

    @Transactional
    public void method2() {
        // Логика method2
    }
}
Только публичные методы: Аннотация работает только на публичных методах. Внутренние вызовы приватных или protected методов не активируют транзакцию.

// Транзакция 1
UPDATE accounts SET balance = balance - 100 WHERE id = 1;

// Транзакция 2 (до фиксации транзакции 1)
SELECT balance FROM accounts WHERE id = 1;

// Транзакция 1
SELECT balance FROM accounts WHERE id = 1;

// Транзакция 2
UPDATE accounts SET balance = balance - 100 WHERE id = 1;

// Транзакция 1 (повторное чтение)
SELECT balance FROM accounts WHERE id = 1;

// Транзакция 1
SELECT * FROM orders WHERE amount > 100;

// Транзакция 2
INSERT INTO orders (id, amount) VALUES (10, 150);

// Транзакция 1 (повторное чтение)
SELECT * FROM orders WHERE amount > 100;

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void processOrder() {
        // Логика обработки заказа
    }
}

public class Task251124_1 {
    public static void main(String[] args) {
        String str = "aabbccddeeff";
        String result = str.replace("aa", "x")
                           .replace("ee", "y")
                           .replace("xx", "z")
                           .replace("dd", "w");
        System.out.println(result);
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class ManualTransactionService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void performManualTransaction() {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setName("CustomTransaction");
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            // Выполнение операций в транзакции
            performDatabaseOperation1();
            performDatabaseOperation2();

            // Фиксация транзакции
            transactionManager.commit(status);
        } catch (Exception ex) {
            // Откат транзакции в случае ошибки
            transactionManager.rollback(status);
            throw ex;
        }
    }

    private void performDatabaseOperation1() {
        // Логика операции 1
    }

    private void performDatabaseOperation2() {
        // Логика операции 2
    }
}
В этом примере транзакция начинается вручную, и ее выполнение зависит от логики программы. Если возникает ошибка, транзакция откатывается.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;

@Service
public class TemplateTransactionService {

    @Autowired
    private TransactionTemplate transactionTemplate;

    public void executeInTransaction() {
        transactionTemplate.execute(status -> {
            try {
                performDatabaseOperation1();
                performDatabaseOperation2();
            } catch (Exception ex) {
                status.setRollbackOnly(); // Указание на откат транзакции
                throw ex;
            }
            return null;
        });
    }

    private void performDatabaseOperation1() {
        // Логика операции 1
    }

    private void performDatabaseOperation2() {
        // Логика операции 2
    }
}

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

COMMIT;
В этом случае изменения будут сохранены в базе данных.

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 2;

ROLLBACK;
В этом случае все изменения будут отменены.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Service
public class ManualTransactionService {

    @Autowired
    private PlatformTransactionManager transactionManager;

    public void transferMoney(Long fromAccountId, Long toAccountId, double amount) {
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        TransactionStatus status = transactionManager.getTransaction(def);

        try {
            // Дебет с одного счета
            debitAccount(fromAccountId, amount);

            // Кредит на другой счет
            creditAccount(toAccountId, amount);

            // Подтверждение транзакции
            transactionManager.commit(status);
        } catch (Exception ex) {
            // Откат транзакции в случае ошибки
            transactionManager.rollback(status);
            throw ex;
        }
    }

    private void debitAccount(Long accountId, double amount) {
        // Логика дебетовой операции
    }

    private void creditAccount(Long accountId, double amount) {
        // Логика кредитной операции
    }
}