import java.util.Map;
import java.util.HashMap;

public class Task051125 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", null);
        
        Integer value1 = map.get("a");
        Integer value2 = map.get("c");
        Integer value3 = map.get("d");
        int value4 = map.getOrDefault("d", -1);
        
        System.out.println(value1);
        System.out.println(value2);
        System.out.println(value3);
        System.out.println(value4);
    }
}

// Пример Java-клиента с авторизационным токеном
ManagedChannel channel = ManagedChannelBuilder
        .forAddress("localhost", 50051)
        .useTransportSecurity()
        .build();

CarServiceGrpc.CarServiceBlockingStub stub = CarServiceGrpc
        .newBlockingStub(channel)
        .withCallCredentials(new CallCredentials() {
            @Override
            public void applyRequestMetadata(
                    RequestInfo requestInfo, Executor executor, MetadataApplier applier) {
                Metadata headers = new Metadata();
                Metadata.Key<String> AUTHORIZATION =
                        Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER);
                headers.put(AUTHORIZATION, "Bearer my-secret-token");
                applier.apply(headers);
            }
        });

public class AuthInterceptor implements ServerInterceptor {
    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
            ServerCall<ReqT, RespT> call,
            Metadata headers,
            ServerCallHandler<ReqT, RespT> next) {

        String token = headers.get(Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER));
        if (token == null || !token.equals("Bearer my-secret-token")) {
            call.close(Status.UNAUTHENTICATED.withDescription("Invalid token"), headers);
            return new ServerCall.Listener<>() {}; // пустой listener
        }

        return next.startCall(call, headers);
    }
}

Server server = ServerBuilder
        .forPort(50051)
        .addService(ServerInterceptors.intercept(new CarServiceImpl(), new AuthInterceptor()))
        .build()
        .start();

import "google/api/annotations.proto";

service CarService {
  rpc GetCar(GetCarRequest) returns (CarResponse) {
    option (google.api.http) = {
      get: "/v1/cars/{id}"
    };
  }
}

ManagedChannel channel = ManagedChannelBuilder
        .forTarget("dns:///my-grpc-service.default.svc.cluster.local")
        .defaultLoadBalancingPolicy("round_robin")
        .usePlaintext()
        .build();

long start = System.nanoTime();
RespT response = next.startCall(call, headers);
long duration = System.nanoTime() - start;
metrics.recordLatency(duration);

message Car {
  reserved 4, 6 to 8;
  reserved "old_model", "legacy_color";
}

package car.v1;
service CarService { ... }

package car.v2;
service CarService { ... }

import java.util.concurrent.ConcurrentHashMap;

public class Task071125 {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("count", 0);

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.computeIfPresent("count", (k, v) -> v + 1);
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.put("count", map.get("count") + 1);
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(map.get("count"));
    }
}