synchronized keyword

package runnable;

public class RunnableTest implements Runnable{
    
    private Object object=new Object();
    private    int a=0;
    public int getA() {
    
        return a;
    }

    public void setA(int a) {
    
        this.a = a;
    }

    @Override
    public void run() {
    
        synchronized (object){
    
            a++;
        }
    }

    public static void main(String[] args) {
    
        long start = System.currentTimeMillis();
        RunnableTest test=new RunnableTest();
        for (int i = 0; i < 100000; i++) {
    
            Thread thread = new Thread(test::run);
            thread.start();
            try {
    
                thread.join();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
        }

        Thread threadX = new Thread(new Runnable() {
    
            public void run() {
    
                System.out.println(test.getA());
                long end = System.currentTimeMillis();
                System.out.println((end-start)+"ms");
            }
        });
        threadX.start();
    }
}

AtomicInteger

package atomic;

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest implements Runnable {
    
    AtomicInteger atomicInteger=new AtomicInteger(0);

    public AtomicInteger getAtomicInteger() {
    
        return atomicInteger;
    }

    public void setAtomicInteger(AtomicInteger atomicInteger) {
    
        this.atomicInteger = atomicInteger;
    }

    @Override
    public void run() {
    
        atomicInteger.incrementAndGet();
    }
    public static void main(String[] args) {
    
        long start = System.currentTimeMillis();
        AtomicIntegerTest test=new AtomicIntegerTest();
        for (int i = 0; i < 100000; i++) {
    
            Thread thread = new Thread(test::run);
            thread.start();
            try {
    
                thread.join();
            } catch (InterruptedException e) {
    
                e.printStackTrace();
                System.out.println(" Add error ");
            }
        }

        Thread threadX = new Thread(new Runnable() {
    
            public void run() {
    
                System.out.println(test.getAtomicInteger());
                long end = System.currentTimeMillis();
                System.out.println((end-start)+"ms");
            }
        });
        threadX.start();
    }
}

LongAdder

package LongAdder;

import java.util.concurrent.atomic.LongAdder;

public class AtomicIntegerTest implements Runnable {
    
    LongAdder longAdder = new LongAdder();
    public LongAdder getLongAdder() {
    
        return longAdder;
    }
    public void setLongAdder(LongAdder longAdder) {
    
        this.longAdder = longAdder;
    }

    @Override
    public void run() {
    
        longAdder.increment();
    }

    public static void main(String[] args) throws InterruptedException {
    
        long start = System.currentTimeMillis();
        AtomicIntegerTest test=new AtomicIntegerTest();
        for (int i = 0; i < 100000; i++) {
    
            Thread thread = new Thread(test::run);
            thread.start();
            thread.join();
        }

        Thread threadX = new Thread(new Runnable() {
    
            public void run() {
    
                System.out.println(test.getLongAdder());
                long end = System.currentTimeMillis();
                System.out.println((end-start)+"ms");
            }
        });
        threadX.start();
    }
}