Java 多线程访问同步方法的七种情况

系统管理员 2021-09-20 17:46 258阅读 0赞

1、两个线程访问一个对象的同步方法

public class SynchronizedObjectMethod3 implements Runnable{
        static SynchronizedObject instance=new SynchronizedObject();
    
        @Override
        public void run() {
            method();
        }
    
        public synchronized  void method(){
            System.out.println("我是对象所的方法修饰符形式，我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程结束");
        }
        public static void main(String[] args){
            //两个线程访问一个对象的同步方法，对象为instance实例
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){
    
            }
            System.out.println("fininshed");
        }
    
    }

--------------------

2、两个线程访问的是两个对象的同步方法，两个对象一个为instance1,另一个为instance2
    public class SynchronizedObject implements Runnable{
        static SynchronizedObject instance1=new SynchronizedObject();
        static SynchronizedObject instance2=new SynchronizedObject();
     /*   Object lock1=new Object();
        Object lock2=new Object();*/
        @Override
        public void run() {
            synchronized (this) {
                System.out.println("我是对象锁的代码块形式，我叫" + Thread.currentThread().getName());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "运行结束");
            }
    
    
        }
        public static void main(String[] args){
            Thread t1=new Thread(instance1);
            Thread t2=new Thread(instance2);//两个线程访问的是两个对象的同步方法，两个对象一个为instance1,另一个为instance2
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){
    
            }
            System.out.println("fininshed");
        }
    }

--------------------

3、两个线程访问synchronized的静态方法

public class SynchronizedClassStatic4 implements Runnable {
        static SynchronizedClassStatic4 instance1=new SynchronizedClassStatic4();
        static SynchronizedClassStatic4 instance2=new SynchronizedClassStatic4();
        @Override
        public void run() {
            method();
        }
    
        public static synchronized void method(){
            System.out.println("我是类锁的一种形式，我叫"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程结束");
        }
        public static void main(String[] args){//两个线程访问synchronized的静态方法
           Thread t1=new Thread(instance1);
            Thread t2=new Thread(instance2);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){
            }
            System.out.println("fininshed");
    
        }
    }

--------------------

4、同时访问同步方法和非同步方法。

public class SynchronizedYesAndNo6 implements Runnable{
        static SynchronizedYesAndNo6 instance=new SynchronizedYesAndNo6();
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("Thread-0")){
                method1();
            }else {
                method2();
            }
    
        }
        public synchronized  void method1(){
            System.out.println("我是加锁的方法"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程执行结束");
    
        }
    
        public  void method2(){
            System.out.println("我是不加锁的方法"+Thread.currentThread().getName()+"线程执行结束");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程执行结束");
    
        }
        public static void main(String[] args) throws InterruptedException{
    
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){}
            System.out.println("ok");
            //结论：同步方法不会出现并发问题，非同步方法不会受到影响，出现并发问题。
    
        }
    }

--------------------

5、访问同一个对象的不同的普通同步方法

public class SynchronizedDifferent7 implements Runnable {
        static SynchronizedDifferent7 instance=new SynchronizedDifferent7();
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("Thread-0")){
                method1();
            }else {
                method2();
            }
    
        }
        public synchronized  void method1(){
            System.out.println("我是加锁的方法"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程执行结束");
    
        }
    
        public synchronized void method2(){
            System.out.println("我也是加锁的方法"+Thread.currentThread().getName()+"线程执行结束");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程执行结束");
    
        }
        public static void main(String[] args) throws InterruptedException{
    
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){}
            System.out.println("ok");
    
        }
    }

--------------------

6、同时访问静态synchronized方法和非静态synchronized方法

public class SynchronizedStaticAndNormal8 implements Runnable{
        static SynchronizedStaticAndNormal8 instance=new SynchronizedStaticAndNormal8();
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("Thread-0")){
                method1();
            }else {
                method2();
            }
    
        }
        public static synchronized  void method1(){
            System.out.println("我是加锁的静态方法1"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程执行结束");
    
        }
    
        public synchronized void method2(){
            System.out.println("我也是加锁的非静态方法2"+Thread.currentThread().getName()+"线程执行结束");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程执行结束");
    
        }
        public static void main(String[] args) throws InterruptedException{
    
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){}
            System.out.println("ok");
    
        }
    }

--------------------

7、方法抛异常后，会释放锁

public class SynchronizedException9 implements Runnable {
        static  SynchronizedException9 instance=new SynchronizedException9();
        @Override
        public void run() {
            if(Thread.currentThread().getName().equals("Thread-0")){
                method1();
            }else {
                method2();
            }
    
        }
        public  synchronized  void method1(){
            System.out.println("我是加锁的静态方法1"+Thread.currentThread().getName());
            try {
                Thread.sleep(3000);
                throw new Exception();//异常抛出后，JVM会自动帮你释放锁，不需要自己手动释放锁。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch (Exception e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程执行结束");

}
    
        public synchronized void method2(){
            System.out.println("我也是加锁的非静态方法2"+Thread.currentThread().getName()+"线程执行结束");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"线程执行结束");
    
        }
        public static void main(String[] args) throws InterruptedException{
    
            Thread t1=new Thread(instance);
            Thread t2=new Thread(instance);
            t1.start();
            t2.start();
            while (t1.isAlive()||t2.isAlive()){}
            System.out.println("ok");
    
        }
    }