线程系列(七)synchronized使用方式

目录

1. synchronized使用方式

2. synchronized 修饰实例方法

3. synchronized 修饰静态方法

4. synchronized 修饰class对象

---

序号	名称	链接地址
1	并发编程系列(一)创建线程的三种方式及线程如何完成上下文如何切换	https://blog.csdn.net/qq_38130094/article/details/103443997
2	并发编程系列(二)之线程的中断	https://blog.csdn.net/qq_38130094/article/details/103444171
3	并发系列(三)线程常用的方法	https://blog.csdn.net/qq_38130094/article/details/103446126
4	并发编程系列(四)之Thread类源码分析(一)	https://blog.csdn.net/qq_38130094/article/details/103448160
5	并发编程系列(五)volatile关键字详解	https://blog.csdn.net/qq_38130094/article/details/103448564
6	并发编程系列(六)volatile 之 as-if-serial 指令重排 volatile内存语义 volatile原理	https://blog.csdn.net/qq_38130094/article/details/103543998
7	线程系列(七)synchronized使用方式	https://blog.csdn.net/qq_38130094/article/details/103537663
8	线程系列(八)synchronized实现原理与应用	https://blog.csdn.net/qq_38130094/article/details/103537668
9	并发编程系列(九)ThreadLocala是如何解决共享变量的并发问题及源码分析	https://blog.csdn.net/qq_38130094/article/details/103665098
10	并发编程系列(十)AQS同步器独占锁加锁与解锁-源码解读	https://blog.csdn.net/qq_38130094/article/details/103540315
11	并发编程系列(十一)AQS同步器共享锁加锁解锁源码解读	https://blog.csdn.net/qq_38130094/article/details/103646505
12	并发编程系列(十二)AQS同步器条件锁(Condition)加锁解锁源码解读	https://blog.csdn.net/qq_38130094/article/details/103679146
13	发编程系列(十三)ReentrantLock 重入锁	https://blog.csdn.net/qq_38130094/article/details/103843779
14	发编程系列(十四)Semaphore信号量	https://blog.csdn.net/qq_38130094/article/details/103846420
15	发编程系列(十五) CountDownLatch闭锁	https://blog.csdn.net/qq_38130094/article/details/103855632
16	并发编程系列(十六) CyclicBarrier	https://blog.csdn.net/qq_38130094/article/details/103859704

Java中的每一个对象都可以作为锁。具体表现为以下3种形式。

1. 对于普通同步方法，锁是当前实例对象。
2. 对于静态同步方法，锁是当前类的Class对象。
3. 对于同步方法块，锁是Synchonized括号里配置的对象。

1. synchronized使用方式

分类	具体分类	锁对象	示例
修饰方法	实例方法	类的实例对象	//修饰普通方法 public synchronized void method(){ }
	静态方法	类对象	//修饰静态方法 public static synchronized void method(){ }
修饰代码块	实例对象	类的实例对象	//同步代码块，锁是实例对象 synchronized (this){ }
	class对象	类对象	//同步代码块，锁是实例对象 synchronized (CLASS){ }
	不同实例对象Object	实例对象Object	//同步代码块，锁是配置的实例对象 Object object = new Object（）; synchronized (object ){ }

2. synchronized 修饰实例方法

/**
 * 两个线程同时对一个对象的一个方法进行操作，只有一个线程能够抢到锁。
 * 因为一个对象只有一把锁，一个线程获取了该对象的锁之后，其他线程无法获取该对象的锁，
 * 就不能访问该对象的其他synchronized实例方法，但是可以访问非synchronized修饰的方法
 */
public class SynchronizedDemo1 implements Runnable{

    public static void main(String[] args) throws InterruptedException {
    	SynchronizedDemo1 test = new SynchronizedDemo1();
        Thread t1 = new Thread(test, "Thread1");
        Thread t2 = new Thread(test, "Thread2");
        t1.start();
        t2.start();
        System.out.println(counter);
    }
    /**
     * 共享资源
     */
    static int counter = 0;
    
	@Override
	public void run() {
		increase();
	}
    /**
     * synchronized 修饰实例方法
     */
    public synchronized void increase() {
        for (int j = 0; j < 10; j++) {
            System.out.println(Thread.currentThread().getName() + "执行累加操作。。。");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter++;
        }
    }
}

3. synchronized 修饰静态方法

/**
 * @Description: synchronized作用于静态方法
 *
 * 两个线程实例化两个不同的对象，但是访问的方法是静态的，两个线程发生了互斥（即一个线程访问，另一个线程只能等着），
 * 因为静态方法是依附于类而不是对象的，当synchronized修饰静态方法时，锁是class对象。
 */
public class SynchronizedTest05 implements Runnable {
    /**
     * 共享资源
     */
    static int counter = 0;

    /**
     * synchronized 修饰静态方法方法
     */
    public static synchronized void increase() {
        for (int j = 0; j < 10; j++) {
            System.out.println(Thread.currentThread().getName() + "执行累加操作。。。");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            counter++;
        }
    }

    @Override
    public void run() {
        increase();
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new SynchronizedTest05(), "线程1");
        Thread t2 = new Thread(new SynchronizedTest05(), "线程2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter);
    }
}

4. synchronized 修饰class对象

/**
 * 修饰类 class
 */
public class SynchronizedTest07 implements Runnable {

    static int counter = 0;

    @Override
    public void run() {
        //省略其他耗时操作....
        //使用同步代码块对变量i进行同步操作,锁对象为instance
        synchronized (SynchronizedTest07.class) {
            for (int j = 0; j < 10; j++) {
                System.out.println(Thread.currentThread().getName() + "执行累加操作。。。");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                counter++;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        final SynchronizedTest07 test = new SynchronizedTest07();
        Thread t1 = new Thread(test, "线程1");
        Thread t2 = new Thread(test,"线程2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter);
    }
}