java的锁有对象锁和类锁两种，但不同的锁在不同的场景下是不同的，区别在于
1.对于普通同步方法，锁是当前实例对象(this)。
2.对于静态同步方法，锁是当前类的Class对象。
3.对于同步方法块，锁是Synchonized括号里配置的对象
讨论到java的八锁问题，我们一般讨论的是java锁住了类还是对象，或者或者是静态方法块
同步方法块之间的讨论
package day2.八锁问题;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
public class test {
@Test
public void test1() throws InterruptedException {
Eat eat=new Eat();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
eat.eat_meat("1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(1);
eat.eat_rice("2");
} catch (Exception e) {
e.printStackTrace();
}
}).start();
Eat eat2=new Eat();
eat2.eat_meat("3");
eat2.eat_rice("4");
TimeUnit.SECONDS.sleep(10);
}
class Eat{
synchronized void eat_rice(String name){
System.out.println("吃饭"+name);
}
synchronized void eat_meat(String name) throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("吃肉" +name);
}
}
}
从这个结果可以看出，如果使用同步语法synchronized，将会锁住对象，但不会锁住类
非同步语法块的讨论
package day2.八锁问题;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
public class test2 {
@Test
public void test1() throws InterruptedException {
Eat eat=new Eat();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(3);
eat.eat_meat();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(3);
eat.eat_rice();
} catch (Exception e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(10);
}
class Eat{
void eat_rice(){
System.out.println("吃饭");
}
synchronized void eat_meat() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("吃肉");
}
}
}
从输出可以到，非同步语法块不会受到同步语法块的限制，提前结束
静态同步语法块之间的讨论
package day2.八锁问题;
import org.junit.Test;
import java.util.concurrent.TimeUnit;
public class test4 {
public static void main(String args[] ) throws InterruptedException {
Eat eat=new Eat();
Eat eat1=new Eat();
new Thread(()->{
try {
eat.eat_meat();
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
try {
eat1.eat_rice();
TimeUnit.SECONDS.sleep(3);
} catch (Exception e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(3);
}
}
package day2.八锁问题;
import java.util.concurrent.TimeUnit;
class Eat2 {
static synchronized void eat_rice() {
System.out.println("吃饭");
}
synchronized void eat_meat() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("吃肉");
}
}
从输出的结果看，同步语法的静态语法块会被锁住顺序输出结果
非静态的同步语法块之间的讨论
package day2.八锁问题;
import java.util.concurrent.TimeUnit;
public class test5 {
public static void main(String args[] ) throws InterruptedException {
Eat2 eat=new Eat2();
Eat2 eat1=new Eat2();
new Thread(()->{
try {
eat.eat_meat();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(1);
new Thread(()->{
try {
eat1.eat_rice();
} catch (Exception e) {
e.printStackTrace();
}
}).start();
TimeUnit.SECONDS.sleep(3);
}
}
package day2.八锁问题;
import java.util.concurrent.TimeUnit;
class Eat2 {
static synchronized void eat_rice() {
System.out.println("吃饭");
}
synchronized void eat_meat() throws InterruptedException {
TimeUnit.SECONDS.sleep(3);
System.out.println("吃肉");
}
}
从输出的结果，可以看到静态语法会锁住类，直到方法执行完毕，释放锁
