什么是线程，线程的创建，synchronized的用法，synchronized的底层原理

1.线程基本概念

进程：电脑上某个软件运行起来是一个进程,比如QQ。
线程：软件运行后进程中最小的执行单元，叫做线程。

2.怎样创建一个线程

可以通过extends Thread或者implements Runnable来创建一个线程，如下

public class MyTest {
    static class Thread1 extends Thread {
        @Override
        public void run() {
            System.out.println("hello thread1");
        }
    }
    static class Thread2 implements Runnable {
        @Override
        public void run() {
            System.out.println("hello thread2");
        }
    }

    public static void main(String[] args) {
        new Thread1().start();
        new Thread(new Thread2()).start();
    }
}

3.synchronized

当多个线程访问同一个临界资源、或者对象时，如多个线程对一个值进行递增，代码如下：

public class MyTest {
    private static int i = 0;
    public void add() {
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        i++;
    }
    public static void main(String[] args) {
        MyTest myTest = new MyTest();
        List<Thread> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(new Thread(myTest::add));
        }
        list.forEach((o)->{
            o.start();
        });
        list.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("没有synchronized锁等于" + i);
    }
}

运行结果：

此处需要加一把synchronized锁把这个递增的逻辑锁起来，每次只能有一个线程访问，从而实现最终递增数据的准确性。修改后得代码如下：

public class MyTest {
    private static int i = 0;
    /**
    * 在方法上添加了synchronize
    */
    public synchronized void add() {
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        i++;
    }
    public static void main(String[] args) {
        MyTest myTest = new MyTest();
        List<Thread> list = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            list.add(new Thread(myTest::add));
        }
        list.forEach((o)->{
            o.start();
        });
        list.forEach((o)->{
            try {
                o.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("加了synchronized锁等于" + i);
    }
}

运行结果：

4.synchronized用法详解

可以在方法上以及代码快中添加synchronized

public class MyTest {
    private static int i = 0;
    public synchronized void add() {
        i++;
    }
    public void add2() {
        synchronized(this) {
            i++;
        }
    }

    public synchronized static void sub() {
        i--;
    }
    Object o  = new Object();
    public void minus() {
        synchronized (o) {
            i = i / 2;
        }
    }
}

synchronized锁的是对象，锁存在Java对象头里，并不是锁的是代码。
add()方法：锁定的是this对象，和synchronize(this)的用法一致，代码中add()和add2()方法锁定的是同一个对象。
也可以通过某个对象进行锁定，如新建对象Object o = new Object()， 通过synchronized(o)进行锁定，如方法minus()。
sub方法锁定的是MyTest.class。

5.synchronized的底层原理

• 早期的synchronized用的是底层实现的重量级锁，每次都要去操作系统中申请锁，效率非常低。
• 后来改进了锁的实现，才有了锁升级的概念。
  锁升级简介：
  1.没有线程访问，则无锁的状态。
  2.如果有一个线程访问，则在对象的头部记录下线程相关信息。我们成为偏向锁。
  3.偏向锁如果有别的线程竞争的话，则升级为自旋锁。自旋锁在cpu中循环，不会进入就绪队列，等待偏向锁释放，循环10次，如果锁释放，则拿到这个锁。
  4.如果自旋锁没有拿到这个锁，则升级为重量级锁，重量级锁需要去操作系统中申请资源。