线程八锁是什么意思？

线程八锁

据说是平常工作中常见的情况，线程八锁的重点就是：
① 非静态方法的默认锁是this
静态方法的默认锁是class
②某一时刻内，只能有一个线程有锁，无论几个方法
打个比方
我就不举八个例子了，举几个重点例子给大家看看：

public class ThreadEightLock {

    public static void main(String[] args) {
        thread t = new thread();
        thread t2 = new thread();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t.getOne();//调用线程一
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t.getTwo();//调用线程二
            }
        }).start();
    }
}

class thread{
    //线程一
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    //线程二
    public synchronized void getTwo(){
        System.out.println("two");
    }
}

代码如上，两个线程都是同一类对象，不同的非静态同步方法，结果是线程一等3秒后输出结果 线程二才会输出

one
two

这是运行结果

因为都是同一吧锁，所以另一个线程进不去。
但是如果一个静态同步方法，一个是非静态同步方法，两个线程都是不同的锁就不会有冲突，代码如下：

package com01;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadEightLock {

    public static void main(String[] args) {
        thread t = new thread();
        thread t2 = new thread();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t.getOne();//调用线程一
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t.getTwo();//调用线程二
            }
        }).start();
    }
}

class thread{
    //线程一
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    //线程二
    public static synchronized void getTwo(){
        System.out.println("two");
    }
}

结果如下

two
one

如果是两个对象，两个非静态同步方法，那么锁就是两个（this）锁，所以也不会冲突 代码如下：

public class ThreadEightLock {

    public static void main(String[] args) {
        thread t = new thread();
        thread t2 = new thread();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t.getOne();//调用线程一
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t2.getTwo();//调用线程二
            }
        }).start();
    }
}

class thread{
    //线程一
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    //线程二
    public synchronized void getTwo(){
        System.out.println("two");
    }
}

结果如下

two
one

然后就是两个对象，两个静态同步方法就会有冲突，因为是（class）锁，代码如下：

public class ThreadEightLock {

    public static void main(String[] args) {
        thread t = new thread();
        thread t2 = new thread();
        new Thread(new Runnable() {
            @Override
            public void run() {
                t.getOne();//调用线程一
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                t2.getTwo();//调用线程二
            }
        }).start();
    }
}

class thread{
    //线程一
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    //线程二
    public static synchronized void getTwo(){
        System.out.println("two");
    }
}

结果如下

one
two

大家是不是有点看不明白，其实只要记住线程八锁的关键就是两句话：

① 非静态方法的默认锁是this ，静态方法的默认锁是class

②某一时刻内，只能有一个线程有锁，无论几个方法