try (var session = MemorySession.openConfined()) {
    MemorySegment segment = MemorySegment.allocateNative(100, session);
    System.out.println("Размер: " + segment.byteSize());
}

try (var session = MemorySession.openConfined()) {
    MemorySegment seg = MemorySegment.allocateNative(8, session);
    seg.set(ValueLayout.JAVA_INT, 0, 42);
    int x = seg.get(ValueLayout.JAVA_INT, 0);
    System.out.println(x);
}

try (var session = MemorySession.openConfined()) {
    MemorySegment seg = MemorySegment.allocateNative(4 * 5, session);
    for (int i = 0; i < 5; i++) {
        seg.setAtIndex(ValueLayout.JAVA_INT, i, i * 10);
    }
    System.out.println(seg.getAtIndex(ValueLayout.JAVA_INT, 3));
}

MemorySegment seg;
try (var session = MemorySession.openConfined()) {
    seg = MemorySegment.allocateNative(16, session);
}
System.out.println(seg.isAlive()); // false

try (var session = MemorySession.openConfined()) {
    MemorySegment seg = MemorySegment.allocateNative(16, session);
    MemorySegment part = seg.asSlice(4, 8);
    System.out.println("Slice: " + part.byteSize());
}

try (var session = MemorySession.openConfined()) {
    MemorySegment seg = MemorySegment.allocateNative(4, session);
    seg.set(ValueLayout.JAVA_INT, 0, 123);
    long addr = seg.address();
    System.out.println("Адрес: " + addr);
}

import jdk.jfr.Event;
import jdk.jfr.Label;

class LoginEvent extends Event {
    @Label("User")
    String username;

    @Label("Success")
    boolean success;
}

LoginEvent e = new LoginEvent();
e.username = "ivan";
e.success = true;
e.commit();

java -XX:StartFlightRecording=filename=recording.jfr,duration=20s -jar app.jar

import jdk.jfr.Category;

@Category("Auth")
class LoginEvent extends Event {
    String username;
}

class CalcEvent extends Event {}

CalcEvent e = new CalcEvent();
e.begin();
// тяжёлая операция
e.end();
e.commit();

LoginEvent e = new LoginEvent();
e.username = "alex";
e.success = false;
e.commit();

System.out.println("Login attempt failed: alex");

class TaskEvent extends Event {
    String thread;
}

TaskEvent e = new TaskEvent();
e.thread = Thread.currentThread().getName();
e.commit();

public record User(String name, int age) {}

class User {
    private final String name;
    private final int age;

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

    public String name() { return name; }
    public int age() { return age; }
}

public record Product(String name, int price) {
    public Product {
        if (price < 0) throw new IllegalArgumentException("price < 0");
    }
}

public sealed class Shape permits Circle, Rectangle {}

public final class Circle extends Shape {}
public final class Rectangle extends Shape {}

public sealed interface Payment
    permits CardPayment, CashPayment {}

public record CardPayment(String number) implements Payment {}
public record CashPayment(double amount) implements Payment {}

Payment p = new CardPayment("1234");

switch (p) {
    case CardPayment c -> System.out.println("💳 " + c.number());
    case CashPayment c -> System.out.println("💵 " + c.amount());
}

sealed interface Command permits Reboot, Shutdown {}

record Reboot() implements Command {}
record Shutdown() implements Command {}

sealed interface Event permits Login, Logout {}

record Login(String user) implements Event {}
record Logout(String user) implements Event {}

String json = """
    {
        "name": "Alice",
        "age": 30
    }
    """;

System.out.println(json);

import java.lang.ScopedValue;

public class Demo {
    static final ScopedValue<String> USER = ScopedValue.newInstance();
}

ScopedValue.where(USER, "Alice").run(() -> {
    System.out.println("Hello, " + USER.get());
});

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() ->
        ScopedValue.where(USER, "Bob").run(() -> {
            System.out.println("User in virtual thread: " + USER.get());
        })
    );
}

ThreadLocal<String> local = new ThreadLocal<>();
local.set("Alice");

ScopedValue.where(USER, "Charlie").run(() -> {
    // USER.set("Dave"); ❌ нельзя
    System.out.println(USER.get());
});

ScopedValue.where(USER, "Admin").run(() -> {
    new Thread(() -> System.out.println(USER.get())).start();
});

🟢 Контекст запроса (user id, trace id).
🟢 Логирование.
🟢 Передача настроек без проброса аргументов.

🔴 Только read-only.
🔴 Живёт только в рамках scope.
🔴 Работает начиная с Java 20+.

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;

try (Arena arena = Arena.openConfined()) {
    Linker linker = Linker.nativeLinker();
    SymbolLookup libc = linker.defaultLookup();
    MethodHandle printf = linker.downcallHandle(
        libc.find("printf").get(),
        FunctionDescriptor.of(ValueLayout.JAVA_INT, ValueLayout.ADDRESS)
    );
    MemorySegment msg = arena.allocateUtf8String("Hello from C!\n");
    printf.invoke(msg);
}

try (Arena arena = Arena.openConfined()) {
    MemorySegment segment = arena.allocate(4);
    segment.set(ValueLayout.JAVA_INT, 0, 1337);
    System.out.println(segment.get(ValueLayout.JAVA_INT, 0));
}

MethodHandle strlen = linker.downcallHandle(
    libc.find("strlen").get(),
    FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
);
long len = (long) strlen.invoke(arena.allocateUtf8String("PyLinux"));
System.out.println(len);

FFM API чётко ограничивает область памяти (через Arena), предотвращая утечки и use-after-free.
Можно использовать “scoped memory” — живёт ровно столько, сколько нужно.

JNI требует перехода между Java и C стэками → дорого.
FFM API компилируется JIT’ом и оптимизируется HotSpot → почти нативная скорость.

jextract -t com.libc /usr/include/stdio.h

🟢 без C-кода,
🟢 без падений JVM,
🟢 без плясок с System.load().

🟠пользователь оплатил заказ,
🟠склад обновил остатки,
🟠ML-модель прислала прогноз.

StreamsBuilder builder = new StreamsBuilder();

KStream<String, String> orders = builder.stream("orders");

orders.groupByKey()
      .windowedBy(TimeWindows.of(Duration.ofMinutes(1)))
      .count()
      .toStream()
      .to("orders_per_minute");

KafkaStreams streams = new KafkaStreams(builder.build(), props);
streams.start();

KTable<String, Long> orderCounts = orders
    .groupByKey()
    .count(Materialized.as("orders-store"));

CREATE STREAM orders_stream (user_id VARCHAR, price DOUBLE)
  WITH (KAFKA_TOPIC='orders', VALUE_FORMAT='JSON');

CREATE TABLE user_revenue AS
  SELECT user_id, SUM(price) AS total
  FROM orders_stream
  WINDOW TUMBLING (SIZE 1 HOUR)
  GROUP BY user_id;

@KafkaListener(topics = "user_revenue")
public void handleRevenue(String msg) {
    System.out.println("💰 " + msg);
}

[orders] → [Kafka Streams: агрегация] → [ksqlDB: фильтрация] → [billing-service]

Kafka Streams хранит state в RocksDB и реплицирует его между инстансами.
Перезапуск — и поток сам продолжает с последнего offset.

@EnableKafkaStreams
@Configuration
public class StreamConfig {
    @Bean
    public KStream<String, String> kStream(StreamsBuilder builder) {
        return builder.stream("orders");
    }
}

Kafka связывает микросервисы, ML, ETL и аналитические пайплайны.
Хранилище, транспорт и очередь — всё в одном.

| Сценарий                      | Что выбрать      |
| ----------------------------- | ---------------- |
| Быстрый прототип, SQL-запросы | ksqlDB           |
| Сложная логика, типизация     | Kafka Streams    |
| Обработка JSON и Avro         | оба поддерживают |
| Глубокая интеграция с Java    | Streams          |

# prometheus.yml
scrape_configs:
  - job_name: 'app'
    static_configs:
      - targets: ['app:8080']

docker run -d -p 9200:9200 elasticsearch
docker run -d -p 5601:5601 kibana

from opentelemetry import trace
tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("db_query"):
    query_database()

pip install opentelemetry-sdk opentelemetry-exporter-otlp

- alert: HighErrorRate
  expr: rate(http_requests_total{status="500"}[5m]) > 0.05
  for: 2m
  labels:
    severity: critical

Код → метрики → логи → трассы — одно пространство событий.
Zipkin, Tempo, Jaeger — строят полную цепочку от запроса до ответа.

Библиотеки сами шлют метрики: Spring Boot Actuator, FastAPI middleware, Django signals.

AWS CloudWatch, GCP Operations Suite, Datadog, New Relic.
Для Kubernetes — Lens, K9s, Grafana Tempo.

Потребитель (Consumer) описывает, что он ждёт от поставщика (Provider).
Provider подтверждает: «Да, я действительно так отвечаю».

@Pact(consumer = "OrderService")
public RequestResponsePact createPact(PactDslWithProvider builder) {
    return builder
        .given("User exists")
        .uponReceiving("a request for user details")
        .path("/users/123")
        .method("GET")
        .willRespondWith()
        .status(200)
        .body("{\"id\":123,\"name\":\"Alex\"}")
        .toPact();
}

@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "UserService", port = "8080")
public void testUserService(MockServer server) {
    Response response = get(server.getUrl() + "/users/123");
    assertEquals(200, response.getStatusCode());
}

@Provider("UserService")
@PactFolder("pacts")
class UserServicePactTest {
    @TestTarget
    final Target target = new HttpTarget(8080);

    @State("User exists")
    public void userExists() {
        // фикстуры для теста
    }
}

docker run -d -p 9292:9292 pactfoundation/pact-broker

Интеграционные тесты требуют запущенные сервисы.
Контрактные тесты — только спецификации.

contract {
    request {
        method 'GET'
        url '/users/123'
    }
    response {
        status 200
        body(id: 123, name: "Alex")
    }
}

➕ Нет неожиданностей при релизах.
➕ CI ломается до продакшена, если кто-то нарушил контракт.
➕ Каждый сервис тестируется изолированно.

➖Нужно поддерживать актуальность контрактов.
➖При множестве сервисов — много файлов.
➖Не ловит ошибки логики (только интерфейсов).

В этом видео автор подробно объясняет концепцию наследования в Java: как один класс может наследовать свойства и методы другого, когда применять `extends`, как переопределять методы и использовать ключевое слово `super`.

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

List<String> lines = Files.readAllLines(Paths.get("data.txt"));
Map<String, Long> counts = lines.stream()
    .flatMap(line -> Arrays.stream(line.split(" ")))
    .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
System.out.println(counts);

StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
DataStream<String> stream = env.socketTextStream("localhost", 9999);

stream
    .flatMap((String line, Collector<String> out) -> {
        for (String word : line.split(" ")) out.collect(word);
    })
    .keyBy(word -> word)
    .sum(1)
    .print();

env.execute("Flink WordCount");

SparkSession spark = SparkSession.builder().appName("StreamSQL").getOrCreate();

Dataset<Row> lines = spark.readStream()
    .format("socket")
    .option("host", "localhost")
    .option("port", 9999)
    .load();

Dataset<Row> words = lines.as(Encoders.STRING())
    .flatMap((FlatMapFunction<String, String>) x -> Arrays.asList(x.split(" ")).iterator(), Encoders.STRING());

words.groupBy("value").count()
    .writeStream()
    .outputMode("complete")
    .format("console")
    .start()
    .awaitTermination();

Pipeline p = Pipeline.create();
p.apply(TextIO.read().from("input.txt"))
 .apply(ParDo.of(new DoFn<String, String>() {
     @ProcessElement
     public void processElement(ProcessContext c) {
         for (String word : c.element().split(" ")) c.output(word);
     }
 }))
 .apply(Count.perElement())
 .apply(TextIO.write().to("output"));
p.run().waitUntilFinish();

FlinkKafkaConsumer<String> consumer = new FlinkKafkaConsumer<>("logs", new SimpleStringSchema(), props);
env.addSource(consumer)
   .map(line -> line.toUpperCase())
   .addSink(new FlinkKafkaProducer<>("processed", new SimpleStringSchema(), props));

stream.keyBy(value -> value)
      .flatMap(new RichFlatMapFunction<String, Tuple2<String, Integer>>() {
          private transient ValueState<Integer> count;
          public void open(Configuration parameters) {
              count = getRuntimeContext().getState(new ValueStateDescriptor<>("count", Integer.class));
          }
          public void flatMap(String value, Collector<Tuple2<String, Integer>> out) throws Exception {
              Integer current = count.value() == null ? 0 : count.value();
              count.update(current + 1);
              out.collect(Tuple2.of(value, current + 1));
          }
      });

PipelineOptions options = PipelineOptionsFactory.create();
options.as(DataflowPipelineOptions.class).setRunner(DataflowRunner.class);

Dataset<Row> df = spark.readStream()
    .format("kafka")
    .option("kafka.bootstrap.servers", "localhost:9092")
    .option("subscribe", "topic")
    .load();

public class MyClass {
    private int field;

    public MyClass(int field) {
        this.field = field;
    }

    public void method() {
        // some code
    }
}

public abstract class AbstractClass {
    public abstract void abstractMethod();

    public void concreteMethod() {
        // some code
    }
}

public class OuterClass {
    static class StaticNestedClass {
        // some code
    }
}

public class OuterClass {
    class InnerClass {
        // some code
    }
}

public class OuterClass {
    public void method() {
        class LocalClass {
            // some code
        }
        LocalClass local = new LocalClass();
    }
}

public class OuterClass {
    public void method() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // some code
            }
        };
    }
}

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public interface MyInterface {
    void myMethod();
}

public record Point(int x, int y) {}

implementation 'org.telegram:telegrambots:6.9.7'

public class EchoBot extends TelegramLongPollingBot {
    public String getBotUsername() { return "MyJavaBot"; }
    public String getBotToken() { return "TOKEN"; }

    public void onUpdateReceived(Update u) {
        var chat = u.getMessage().getChatId().toString();
        var text = u.getMessage().getText();
        send(chat, "Ты написал: " + text);
    }

    void send(String chatId, String msg) {
        try { execute(new SendMessage(chatId, msg)); } 
        catch (Exception e) { e.printStackTrace(); }
    }
}

var bots = new TelegramBotsApi(DefaultBotSession.class);
bots.registerBot(new EchoBot());
System.out.println("Бот в деле 🚀");

Ты: ping  
Бот: Ты написал: ping

if (text.equals("/start"))
    send(chat, "Привет! Я Java-бот 💪");
else if (text.equalsIgnoreCase("время"))
    send(chat, LocalTime.now().toString());
else
    send(chat, "Команда не понята 🤖");

var markup = new InlineKeyboardMarkup();
markup.setKeyboard(List.of(List.of(
    new InlineKeyboardButton("Сказать hi").callbackData("hi")
)));
msg.setReplyMarkup(markup);

src/
 ├── Main.java
 └── EchoBot.java
build.gradle

Socket socket = new Socket("api.exchange.com", 4001);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

out.println("SUBSCRIBE:BTC-USD");
System.out.println("Tick: " + in.readLine());

Selector selector = Selector.open();
SocketChannel channel = SocketChannel.open(new InetSocketAddress("api.exchange.com", 8080));
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);

while (true) {
    selector.select();
    for (SelectionKey key : selector.selectedKeys())
        ((SocketChannel) key.channel()).read(ByteBuffer.allocate(1024));
}

HttpClient client = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build();
HttpRequest req = HttpRequest.newBuilder(URI.create("https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT")).build();
String body = client.send(req, HttpResponse.BodyHandlers.ofString()).body();
System.out.println(body);

Flux.interval(Duration.ofMillis(10))
    .flatMap(i -> fetchTick())
    .subscribe(System.out::println);

ProducerRecord<String, String> tick = new ProducerRecord<>("ticks", "BTC", json);
producer.send(tick);

Disruptor<Event> disruptor = new Disruptor<>(Event::new, 1024, Executors.defaultThreadFactory());
disruptor.handleEventsWith((event, seq, end) -> process(event));
disruptor.start();

double pnl = 0.0;
for (int i = 0; i < prices.length; i++)
    pnl += (prices[i] - avg) * weights[i];

ChronicleQueue queue = ChronicleQueue.single("trades");
ExcerptAppender appender = queue.acquireAppender();
appender.writeText("BUY BTC 1.234 @ 67900");

long t1 = System.nanoTime();
client.send(request, HttpResponse.BodyHandlers.discarding());
System.out.println("Latency: " + (System.nanoTime() - t1) / 1_000_000.0 + " ms");

CompletableFuture.supplyAsync(() -> fetch("exchangeA"))
    .exceptionally(e -> fetch("exchangeB"))
    .thenAccept(this::trade);

JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser(stream);
while (parser.nextToken() != JsonToken.END_OBJECT)
    process(parser.getCurrentName(), parser.getValueAsString());

NtpV3Packet msg = new NtpV3Impl();
msg.setMode(3);
System.out.println("Offset: " + client.getTime(InetAddress.getByName("pool.ntp.org")).getOffset());

implementation("io.opentelemetry:opentelemetry-api:1.31.0")
implementation("io.opentelemetry:opentelemetry-sdk:1.31.0")
implementation("io.opentelemetry:opentelemetry-exporter-otlp:1.31.0")

SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
    .addSpanProcessor(BatchSpanProcessor.builder(OtlpGrpcSpanExporter.builder().build()).build())
    .build();

OpenTelemetry openTelemetry = OpenTelemetrySdk.builder()
    .setTracerProvider(tracerProvider)
    .build();

Tracer tracer = openTelemetry.getTracer("com.trading.app");
try (Scope scope = tracer.spanBuilder("DB Query").startScopedSpan()) {
    db.execute("SELECT * FROM orders");
}

Meter meter = openTelemetry.getMeter("com.trading.metrics");
LongCounter reqCount = meter.counterBuilder("http.requests.total").build();

reqCount.add(1, Attributes.of(stringKey("endpoint"), "/api/trade"));

OtlpGrpcMetricExporter exporter = OtlpGrpcMetricExporter.builder()
    .setEndpoint("http://localhost:4317")
    .build();

logger.info("order_created", kv("user", userId), kv("amount", amount));

java -javaagent:opentelemetry-javaagent.jar \
  -Dotel.service.name=order-service \
  -Dotel.exporter.otlp.endpoint=http://localhost:4317 \
  -jar app.jar

receivers:
  otlp:
    protocols:
      grpc:
      http:

exporters:
  prometheus:
  logging:
  jaeger:
    endpoint: "localhost:14250"

service:
  pipelines:
    traces: { receivers: [otlp], exporters: [jaeger, logging] }
    metrics: { receivers: [otlp], exporters: [prometheus] }

Traces → Jaeger  
Metrics → Prometheus  
Logs → Loki  

MDC.put("traceId", Span.current().getSpanContext().getTraceId());
logger.info("processing order {}", orderId);

➡️ CPU / Memory / GC Time
➡️ Request latency per endpoint
➡️ Top error spans per service
➡️ Logs correlated by traceId

try (Scope scope = tracer.spanBuilder("match_order").startScopedSpan()) {
    orderService.match(order);
}

В этом видео автор анализирует, насколько Java остаётся актуальной в 2025 году и какие изменения произошли в языке и экосистеме.
Разбираются ключевые области применения Java — от корпоративных систем и Android-разработки до backend-сервисов — и сравнивается её востребованность с другими языками программирования.