1.java中实现多线程的几种方式

java中实现多线程的方式主要有两种，第一种是继承Thread类，第二种是实现Runnable接口。

class Thread1 extends Thread{
    @Override
    public void run{
        System.out.println("thread1 do something");
    }
}

class Thread2 implements Runnable{
    @Override
    public void run{
        System.out.println("thread2 do something");
    }
}

上面的代码估计大家都非常熟悉，平时项目中主要使用实现Runnable接口的方式，这是因为java是单继承特性，实现接口比继承更加灵活，而且一个Runnable类可以被多个线程使用。这部分知识点比较简单，就不做重点研究了。

2.synchronized关键字

1.synchronized对象锁

public class Test{
    
    public synchronized void method1(){}
    
    public void method2(){
        
        synchronized(this){
            
        }
        
    }
    
}

上面代码中method1方法和method2方法都持有Test对象的锁，这两种写法本质上是一样的。

2.synchronized线程间通信

public class Main{
    
    public static void main(String[] args){
        MyObj obj = new MyObj();
        new ThreadA(obj).start();
        new ThreadB(obj).start();
    }
    
}

class MyObj{
    
    public synchronized void methodA(){}
    
    public synchronized void methodB(){}
    
}

class ThreadA extends Thread{
    
    private MyObj obj;
    
    public ThreadA(MyObj obj){
        this.obj = obj;
    }
    
    @Override
    public void run(){
        obj.methodA();
    }
}

class ThreadB extends Thread{
    
    private MyObj obj;
    
    public ThreadB(MyObj obj){
        this.obj = obj;
    }
    
    @Override
    public void run(){
        obj.methodB();
    }
}

上面这段代码Myobj类有methodA和methodB这两个同步方法，持有的都是MyObj的对象锁。ThreadA和ThreadB都持有MyObj对象实例，是同一份内存。执行上面的代码，你会发现只有当ThreadA中执行完了methodA方法后，ThreadB才能执行methodB方法。这是因为，ThradA执行methodA先获得的MyObj对象锁，获得了访问内存的权限，当ThreadA执行完method方法后，释放了MyObj的对象锁，而ThreadB方法在执行methodB方法时，MyObj对象锁被ThreadA持有，所以只能先进入等待状态，ThreadA释放MyObj对象锁后，ThreadB获得MyObj对象锁，也获得了这块内存的访问权限。言而总之，谁获得了对象锁，谁就获得了这块内存的访问权限。这种多线程共享对象进行锁的管理就是synchronized线程间通信。

3.synchronized/volatile

class Test{
    
    private int a;
    private volatile int b;
    private int c;
    public int getA(){ return a;}
    public int getB(){ return b;}
    public synchronized int getC(){ return c;}
    
}

上面这段代码中，如果有多个线程去调用getA方法，那么所获得到的a的值很有可能是不一样的，这是因为获得是线程空间中主内存的copy，如果一个线程改变了a的值，并不会去通知其他线程a的值改变了。如果有多线程去调用getB方法，获得到值是一样的。这是由于b属性被volatile修饰了，被volatile修饰的属性相当于告诉jvm，这个值是不确定的，需要从主内存去获取，所以b能保证一致性。而多线程调用getC方法时，会造成后面线程的堵塞等待，也能保证值得一致性。当一个线程执行getC方法时，线程空间会从主内存中copy数据到本地，然后执行修改，完成操作后会将线程空间的数据与主内存中的数据同步，然后释放对象锁，交由下个线程处理。
总结下synchronized和volatile的区别，第一，在多线程下，volatile不堵塞的，数据直接从主内存中获取，synchronized是堵塞的，线程处理完数据要与主内存数据同步，并通知其他线程数据的改变。第二，volatile仅能使用在变量级别,synchronized则可以使用在变量,方法。

4.synchronized/lock

synchronized和lock的区别主要从两个方面讲，从用法上，synchronized可以加载类上，方法上，属性上，要指定锁住的对象。而lock要指定起始位置和终止位置。从性能上，synchronized是依赖于jvm，而lock依赖于我们的java代码，比起synchronized属于轻量级操作，所以在并发量比较小的情况下，使用synchronized是个不错的选择，但是在并发量比较高的情况下，其性能下降很严重，此时Lock是个不错的方案。从本质上讲，synchronized采用的是cpu的悲观锁机制，线程获得的是独占锁，其他线程要通过堵塞的方式等待；lock采用的是cpu的乐观锁机制，不加锁，假设没有冲突去执行操作，如果失败就重复试，值到成功为止

5.sleep/wait

两者最主要的区别是sleep没有释放锁，只是让当前线程进入睡眠状态，wait会交出锁进入等待状态，别的线程可以工作

6.wait/notify

两者必须在同步代码块中执行。当线程执行wait()时，会把当前的锁释放，然后让出CPU，进入等待状态。当执行notify方法时，会唤醒一个处于等待该 对象锁 的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。