synchronized同步方法

阿新 • • 發佈：2020-10-14

package JavaMultiThread;
/*
 * 例項變數的非執行緒安全
 */
public class t3 {
    public static void main(String[] args) {
        HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
        HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();
        
        ThreadA thread1 = new ThreadA(numRef1);
        thread1.start();
        
        ThreadB thread2  
= new ThreadB(numRef1);
        thread2.start();
        
    }

}

class HasSelfPrivateNum{
    private int num = 0;
    synchronized public void addI(String username) {
        try {
            if(username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep( 
2000);
            }else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num = " + num);
        } catch (InterruptedException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }
    }
}



 
class ThreadA extends Thread{
    private HasSelfPrivateNum numRef;
    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }
    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }
}

class ThreadB extends Thread{
    private HasSelfPrivateNum numRef;
    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }
    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }
}

a set over!
a num = 100
b set over!
b num = 200

package JavaMultiThread;
/*
 * 多個物件多個鎖
 */
public class t3 {
    public static void main(String[] args) {
        HasSelfPrivateNum numRef1 = new HasSelfPrivateNum();
        HasSelfPrivateNum numRef2 = new HasSelfPrivateNum();
        
        ThreadA thread1 = new ThreadA(numRef1);
        thread1.start();
        
        ThreadB thread2 = new ThreadB(numRef2);
        thread2.start();
        
    }

}

class HasSelfPrivateNum{
    private int num = 0;
    synchronized public void addI(String username) {
        try {
            if(username.equals("a")) {
                num = 100;
                System.out.println("a set over!");
                Thread.sleep(2000);
            }else {
                num = 200;
                System.out.println("b set over!");
            }
            System.out.println(username + " num = " + num);
        } catch (InterruptedException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }
    }
}



class ThreadA extends Thread{
    private HasSelfPrivateNum numRef;
    public ThreadA(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }
    @Override
    public void run() {
        super.run();
        numRef.addI("a");
    }
}

class ThreadB extends Thread{
    private HasSelfPrivateNum numRef;
    public ThreadB(HasSelfPrivateNum numRef) {
        super();
        this.numRef = numRef;
    }
    @Override
    public void run() {
        super.run();
        numRef.addI("b");
    }
}

a set over!
b set over!
b num = 200
a num = 100

package JavaMultiThread;
/*
 *synchronized鎖住的是物件（不加鎖）
 */
public class t1 {
    public static void main(String[] args) {
        MyObject object = new MyObject();
        ThreadH a = new ThreadH(object);
        a.setName("A");
        
        ThreadH b = new ThreadH(object);
        b.setName("B");
        
        a.start();
        b.start();
    }
}

class MyObject{
    public void methodA() {
        try {
            System.out.println("begin methodA threadName = " + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end!");
        } catch (InterruptedException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }
    }
    
    
    
}


class ThreadH extends Thread{    
    private MyObject object;
    public ThreadH( MyObject object) {    //用MyObject物件建立Threada程序
        super();
        this.object = object;
    }
    
    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}

begin methodA threadName = A
begin methodA threadName = B
end!
end!

package JavaMultiThread;
/*
 *synchronized鎖住的是物件
 */
public class t1 {
    public static void main(String[] args) {
        MyObject object = new MyObject();
        ThreadH a = new ThreadH(object);
        a.setName("A");
        
        ThreadH b = new ThreadH(object);
        b.setName("B");
        
        a.start();
        b.start();
    }
}

class MyObject{
    synchronized public void methodA() {
        try {
            System.out.println("begin methodA threadName = " + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end!");
        } catch (InterruptedException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }
    }
    
    
    
}


class ThreadH extends Thread{    
    private MyObject object;
    public ThreadH( MyObject object) {    //用MyObject物件建立Threada程序
        super();
        this.object = object;
    }
    
    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}

begin methodA threadName = A
end!
begin methodA threadName = B
end!

package JavaMultiThread;

public class t1 {
    public static void main(String[] args) {
        MyObject object = new MyObject();
        ThreadH a = new ThreadH(object);
        a.setName("A");
        
        ThreadC b = new ThreadC(object);
        b.setName("B"); 
        
        a.start();
        b.start();
    }
}

class MyObject{
    synchronized public void methodA() {
        try {
            System.out.println("begin methodA threadName = " + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end endTime = " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }
    }
    public void methodB() {
        try {
            System.out.println("begin methodB threadName = " + Thread.currentThread().getName()
                    + " begin time = " + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }
    }
}


class ThreadH extends Thread{    
    private MyObject object;
    public ThreadH( MyObject object) {    //用MyObject物件建立Threada程序
        super();
        this.object = object;
    }
    
    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}

class ThreadC extends Thread{    
    private MyObject object;
    public ThreadC( MyObject object) {    //用MyObject物件建立Threada程序
        super();
        this.object = object;
    }
    
    @Override
    public void run() {
        super.run();
        object.methodB();
    }
}

begin methodA threadName = A
begin methodB threadName = B begin time = 1602684531118
end endTime = 1602684535614
end

package JavaMultiThread;

public class t1 {
    public static void main(String[] args) throws InterruptedException {
        MyObject object = new MyObject();
        ThreadH a = new ThreadH(object);
        a.setName("A");
        
        ThreadC b = new ThreadC(object);
        b.setName("B"); 
        
        a.start();
        Thread.sleep(500);
        b.start();
    }
}

class MyObject{
    synchronized public void methodA() {
        try {
            System.out.println("begin methodA threadName = " + Thread.currentThread().getName());
            Thread.sleep(5000);
            System.out.println("end endTime = " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }
    }
    synchronized public void methodB() {
        try {
            System.out.println("begin methodB threadName = " + Thread.currentThread().getName()
                    + " begin time = " + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("end");
        } catch (InterruptedException e) {
            // TODO 自動生成的 catch 塊
            e.printStackTrace();
        }
    }
}


class ThreadH extends Thread{    
    private MyObject object;
    public ThreadH( MyObject object) {    //用MyObject物件建立Threada程序
        super();
        this.object = object;
    }
    
    @Override
    public void run() {
        super.run();
        object.methodA();
    }
}

class ThreadC extends Thread{    
    private MyObject object;
    public ThreadC( MyObject object) {    //用MyObject物件建立Threada程序
        super();
        this.object = object;
    }
    
    @Override
    public void run() {
        super.run();
        object.methodB();
    }
}

begin methodA threadName = A
end endTime = 1602684573421
begin methodB threadName = B begin time = 1602684573421
end

Java多執行緒synchronized同步方法詳解

1、synchronized 方法與鎖物件　　執行緒鎖的是物件。　　1）A執行緒先持有 object 物件的 Lock 鎖， B執行緒可以以非同步的方式呼叫 object 物件中的非 synchronized 型別的方法

多執行緒：通過兩個不安全例子學習同步鎖，synchronized同步方法/同步塊，JUC, lock鎖

模擬搶購火車票 package com.cl.syn; //不安全買票，會出現多人買同一張票，導致票數出現負數

synchronized同步方法

package JavaMultiThread; /* * 例項變數的非執行緒安全 */ public class t3 { public static void main(String[] args) {

Java多執行緒訪問Synchronized同步方法的八種使用場景

簡介本文將介紹7種同步方法的訪問場景，我們來看看這七種情況下，多執行緒訪問同步方法是否還是執行緒安全的。這些場景是多執行緒程式設計中經常遇到的，而且也是面試時高頻被問到的問題，所以不管是理論還是實踐，

原始碼解析Synchronized同步方法的八種使用場景，收藏

簡介本文將介紹8種同步方法的訪問場景，我們來看看這八種情況下，多執行緒訪問同步方法是否還是執行緒安全的。這些場景是多執行緒程式設計中經常遇到的，而且也是面試時高頻被問到的問題，所以不管是理論還是實踐，

synchronized同步方法——T21

技術標籤：多執行緒多執行緒java併發程式設計 package 物件及變數的併發訪問2;

多執行緒訪問Synchronized同步方法的8種使用場景

技術標籤：【Java-併發程式設計】目錄 1、場景一：兩個執行緒同時訪問同一個物件的同步方法

用程式碼說話：synchronized關鍵字和多執行緒訪問同步方法的7種情況

synchronized關鍵字在多執行緒併發程式設計中一直是元老級角色的存在，是學習併發程式設計中必須面對的坎，也是走向Java高階開發的必經之路。

java synchronized靜態同步方法與非靜態同步方法，同步語句塊

技術標籤：java核心程式設計java多執行緒面試對程式碼進行同步控制我們可以選擇同步方法，也可以選擇同步塊，這兩種方式各有優缺點。同步塊不僅可以更加精確的控制物件鎖，還可以控制鎖的作用域，何謂鎖的作用域

Java多執行緒之執行緒同步方法：synchronized與Lock

一、什麼是執行緒同步？多個執行緒操作同一個資源,即併發問題：同一個物件被多個執行緒同時操作

12 | 多執行緒之鎖優化（上）：深入瞭解Synchronized同步鎖的優化方法

背景：感覺講的不錯，可以學習理解你好，我是劉超。從這講開始，我們就正式進入到第三模組——多執行緒效能調優。

Synchronized同步鎖實現原理

修飾程式碼塊 // 關鍵字在程式碼塊上，鎖為括號裡面的物件 public void method2() {

Java同步程式碼塊和同步方法原理與應用案例詳解

本文例項講述了Java同步程式碼塊和同步方法。分享給大家供大家參考，具體如下：

Java實現執行緒同步方法及原理詳解

一、概述無論是什麼語言，在多執行緒程式設計中，常常會遇到多個線同時操作程某個變數(讀/寫)，如果讀/寫不同步，則會造成不符合預期的結果。

Java非同步呼叫轉同步方法例項詳解

先說一下對非同步和同步的理解：同步呼叫：呼叫方在呼叫過程中，持續等待返回結果。

Java中多執行緒的使用（超級超級詳細）執行緒安全+執行緒鎖原理解析+保證執行緒安全的三種方式（同步程式碼塊+同步方法+lock鎖） 5

Java中多執行緒的使用（超級超級詳細）執行緒安全+保證執行緒安全的三種方式（同步程式碼塊+同步方法+lock鎖） 5

執行緒同步方法及同步塊

執行緒同步方法及同步塊同步方法由於我們可以通過private關鍵字來保證資料物件只能被方法訪問，所以我們只需要針對方法提出一套機制，這套機制就是synchronized關鍵字，它包括兩種用法：

解決執行緒安全的兩種同步機制同步程式碼塊和同步方法

1.背景例子：建立個視窗賣票，總票數為100張.使用實現Runnable介面的方式** 1.問題：賣票過程中，出現了重票、錯票 -->出現了執行緒的安全問題* 2.問題出現的原因：當某個執行緒操作車票的過程中，尚未操作完成時

Java執行緒原理和5種同步方法

Java執行緒原理和5種同步方法自己開發了一個股票智慧分析軟體，功能很強大，需要的點選下面的連結獲取：

Java-多執行緒-安全性-同步方法技術

package cn.bruce.Thread; //多執行緒售票案例 //解決安全問題，JAVA程式提供了同步技術synchronized(任意物件){執行緒要操作的共享資料}

synchronized同步方法

相關推薦