并发编程(synchronized)

青旅半醒 2022-03-21 14:15 285阅读 0赞

##### 1修饰方法 #####

如下

public synchronized void method(){ // todo}
    or 
    public void method(){synchronized(this) {// todo }}

##### 2修饰一个代码块 #####

`1.一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞`  
`2.当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块`

public  void run() {
    	      synchronized(this) {
    	         for (int i = 0; i < 5; i++) {
    	            try {
    	               System.out.println(Thread.currentThread().getName() + ":" + (count++));
    	               Thread.sleep(100);
    	            } catch (InterruptedException e) {
    	               e.printStackTrace();
    	            }
    	         }
    	      }
    	   }

##### 3指定要给某个对象加锁 #####

'当有一个明确的对象作为锁时'
    /**
     * 银行账户类
     */
    class Account {
       String name;
       float amount;
     
       public Account(String name, float amount) {
          this.name = name;
          this.amount = amount;
       }
       //存钱
       public  void deposit(float amt) {
          amount += amt;
          try {
             Thread.sleep(100);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
       }
       //取钱
       public  void withdraw(float amt) {
          amount -= amt;
          try {
             Thread.sleep(100);
          } catch (InterruptedException e) {
             e.printStackTrace();
          }
       }
     
       public float getBalance() {
          return amount;
       }
    }
     
    /**
     * 账户操作类
     */
    class AccountOperator implements Runnable{
       private Account account;
       public AccountOperator(Account account) {
          this.account = account;
       }
     
       public void run() {
          synchronized (account) {
             account.deposit(500);
             account.withdraw(500);
             System.out.println(Thread.currentThread().getName() + ":" + account.getBalance());
          }
       }
    }
     
    public class Demo00{
    	
    	//public static final Object signal = new Object(); // 线程间通信变量
    	//将account改为Demo00.signal也能实现线程同步
    	public static void main(String args[]){
    		Account account = new Account("zhang san", 10000.0f);
    		AccountOperator accountOperator = new AccountOperator(account);
     
    		final int THREAD_NUM = 5;
    		Thread threads[] = new Thread[THREAD_NUM];
    		for (int i = 0; i < THREAD_NUM; i ++) {
    		   threads[i] = new Thread(accountOperator, "Thread" + i);
    		   threads[i].start();
    		}
    	}
    }

"当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁"
    class Test implements Runnable
    {
       private byte[] lock = new byte[0];  // 特殊的instance变量
       public void method()
       {
          synchronized(lock) {
             // todo 同步代码块
          }
       }
       public void run() {
       }
    }

##### 4修饰一个静态的方法 #####

"静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象"
    public synchronized static void method() {
       // todo
    }

class SyncThread implements Runnable {
       private static int count;
     
       public SyncThread() {
          count = 0;
       }
    
       public synchronized static void method() {
          for (int i = 0; i < 5; i ++) {
             try {
                System.out.println(Thread.currentThread().getName() + ":" + (count++));
                Thread.sleep(100);
             } catch (InterruptedException e) {
                e.printStackTrace();
             }
          }
       }
     
       public synchronized void run() {
          method();
       }
    }
     
    public class Demo00{
    	public static void main(String args[]){
    		SyncThread syncThread1 = new SyncThread();
    		SyncThread syncThread2 = new SyncThread();
    		Thread thread1 = new Thread(syncThread1, "SyncThread1");
    		Thread thread2 = new Thread(syncThread2, "SyncThread2");
    		thread1.start();
    		thread2.start();
    	}
    }

##### 5修饰一个静态的方法 #####

`Synchronized还可作用于一个类`

class ClassName {
       public void method() {
          synchronized(ClassName.class) {
             // todo
          }
       }
    }

/**
     * 同步线程
     */
    class SyncThread implements Runnable {
       private static int count;
     
       public SyncThread() {
          count = 0;
       }
       public static void method() {
          synchronized(SyncThread.class) {
             for (int i = 0; i < 5; i ++) {
                try {
                   System.out.println(Thread.currentThread().getName() + ":" + (count++));
                   Thread.sleep(100);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }
             }
          }
       }
       public synchronized void run() {
          method();
       }
    }

[原文地址][Link 1]

[Link 1]: https://blog.csdn.net/sinat_32588261/article/details/72880159