java 기본 강좌의synchronized 키워드
1. synchronized 원리
자바에서는 모든 대상이 있고 동기화 자물쇠만 있습니다.이것 또한 동기화 자물쇠는 대상에 의존하여 존재한다는 것을 의미한다.우리가 어떤 대상의synchronized 방법을 호출할 때, 이 대상의 동기화 자물쇠를 가져옵니다.예를 들어synchronized(obj)는'obj 이 대상'의 동기화 자물쇠를 가져옵니다.서로 다른 라인이 동기화 자물쇠에 대한 접근은 서로 배제된다.즉, 어느 시간에 대상의 동기화 자물쇠는 한 라인에서만 얻을 수 있다!동기화 자물쇠를 통해 우리는 다중 노드에서'대상/방법'에 대한 상호 배척 접근을 실현할 수 있다.예를 들어, 현재 두 개의 스레드 A와 스레드 B가 있는데, 모두'대상 obj의 동기화 자물쇠'에 접근할 것이다.가령, 어느 순간에 스레드 A가'obj의 동기화 자물쇠'를 얻고 일부 조작을 실행한다고 가정한다.이때 스레드 B도'obj의 동기화 자물쇠'를 가져오려고 합니다. 스레드 B는 가져오는 데 실패합니다. 스레드 A가'이 대상의 동기화 자물쇠'를 푼 후에야 스레드 B가'obj의 동기화 자물쇠'를 가져와 실행할 수 있도록 기다려야 합니다.2. synchronized 기본 규칙
우리는synchronized의 기본 규칙을 아래 세 가지로 요약하고 실례를 통해 그것들에 대해 설명할 것이다.첫 번째: 한 라인이'어떤 대상'의'synchronized 방법'이나'synchronized 코드 블록'에 접근할 때, 다른 라인이'이 대상'의'synchronized 방법'이나'synchronized 코드 블록'에 대한 접근이 막힙니다.제2조: 한 라인이'어떤 대상'의'synchronized 방법'이나'synchronized 코드 블록'에 접근할 때 다른 라인은'이 대상'의 비동기화 코드 블록에 접근할 수 있다.제3조: 한 라인이'어떤 대상'의'synchronized 방법'이나'synchronized 코드 블록'에 접근할 때 다른 라인이'이 대상'의 다른'synchronized 방법'이나'synchronized 코드 블록'에 대한 접근이 막힌다.
제1조
한 라인이'어떤 대상'의'synchronized 방법'이나'synchronized 코드 블록'에 접근할 때, 다른 라인이'이 대상'의'synchronized 방법'이나'synchronized 코드 블록'에 대한 접근이 막힙니다.다음은'synchronized 코드 블록'에 대응하는 프레젠테이션 프로그램입니다.
class MyRunable implements Runnable {
@Override
public void run() {
synchronized(this) {
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName() + " loop " + i);
}
} catch (InterruptedException ie) {
}
}
}
}
public class Demo1_1 {
public static void main(String[] args) {
Runnable demo = new MyRunable(); // “Runnable ”
Thread t1 = new Thread(demo, "t1"); // “ t1”, t1 demo Runnable
Thread t2 = new Thread(demo, "t2"); // “ t2”, t2 demo Runnable
t1.start(); // “ t1”
t2.start(); // “ t2”
}
}
t1 loop 0
t1 loop 1
t1 loop 2
t1 loop 3
t1 loop 4
t2 loop 0
t2 loop 1
t2 loop 2
t2 loop 3
t2 loop 4
만약 네가 확인한다면, 너는 이 문제를 분명히 할 것이다.그러면 우리는 위의 코드를 수정한 후에 다시 실행해서 결과가 어떤지, 네가 헷갈릴지 봅시다.수정된 소스 코드는 다음과 같습니다.
class MyThread extends Thread {
public MyThread(String name) {
super(name);
}
@Override
public void run() {
synchronized(this) {
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName() + " loop " + i);
}
} catch (InterruptedException ie) {
}
}
}
}
public class Demo1_2 {
public static void main(String[] args) {
Thread t1 = new MyThread("t1"); // “ t1”
Thread t2 = new MyThread("t2"); // “ t2”
t1.start(); // “ t1”
t2.start(); // “ t2”
}
}
t1 loop 0
t2 loop 0
t1 loop 1
t2 loop 1
t1 loop 2
t2 loop 2
t1 loop 3
t2 loop 3
t1 loop 4
t2 loop 4
제2조
한 라인이'어떤 대상'의'synchronized 방법'이나'synchronized 코드 블록'에 접근할 때, 다른 라인은 여전히'이 대상'의 비동기화 코드 블록에 접근할 수 있다.다음은'synchronized 코드 블록'에 대응하는 프레젠테이션 프로그램입니다.
class Count {
// synchronized
public void synMethod() {
synchronized(this) {
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName() + " synMethod loop " + i);
}
} catch (InterruptedException ie) {
}
}
}
//
public void nonSynMethod() {
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);
}
} catch (InterruptedException ie) {
}
}
}
public class Demo2 {
public static void main(String[] args) {
final Count count = new Count();
// t1, t1 “count ” synMethod()
Thread t1 = new Thread(
new Runnable() {
@Override
public void run() {
count.synMethod();
}
}, "t1");
// t2, t2 “count ” nonSynMethod()
Thread t2 = new Thread(
new Runnable() {
@Override
public void run() {
count.nonSynMethod();
}
}, "t2");
t1.start(); // t1
t2.start(); // t2
}
}
t1 synMethod loop 0
t2 nonSynMethod loop 0
t1 synMethod loop 1
t2 nonSynMethod loop 1
t1 synMethod loop 2
t2 nonSynMethod loop 2
t1 synMethod loop 3
t2 nonSynMethod loop 3
t1 synMethod loop 4
t2 nonSynMethod loop 4
제3조
한 라인이'어떤 대상'의'synchronized 방법'이나'synchronized 코드 블록'에 접근할 때, 다른 라인이'이 대상'의 다른'synchronized 방법'이나'synchronized 코드 블록'에 대한 접근이 막힙니다.우리는 위의 예 중의 nonsynMethod () 방법체도 synchronized (this) 로 수식할 것이다.수정된 소스 코드는 다음과 같습니다.
class Count {
// synchronized
public void synMethod() {
synchronized(this) {
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName() + " synMethod loop " + i);
}
} catch (InterruptedException ie) {
}
}
}
// synchronized
public void nonSynMethod() {
synchronized(this) {
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + " nonSynMethod loop " + i);
}
} catch (InterruptedException ie) {
}
}
}
}
public class Demo3 {
public static void main(String[] args) {
final Count count = new Count();
// t1, t1 “count ” synMethod()
Thread t1 = new Thread(
new Runnable() {
@Override
public void run() {
count.synMethod();
}
}, "t1");
// t2, t2 “count ” nonSynMethod()
Thread t2 = new Thread(
new Runnable() {
@Override
public void run() {
count.nonSynMethod();
}
}, "t2");
t1.start(); // t1
t2.start(); // t2
}
}
synMethod() : 11
synBlock() : 3
인스턴스 잠금과 글로벌 잠금에 대한 이미지는 다음과 같습니다.
pulbic class Something {
public synchronized void isSyncA(){}
public synchronized void isSyncB(){}
public static synchronized void cSyncA(){}
public static synchronized void cSyncB(){}
}
(01) 동시에 액세스할 수 없습니다.isSynca () 와 isSyncB () 는 같은 객체 (객체 x) 에 액세스하는 동기화 잠금이기 때문입니다!
// LockTest2.java
class Something {
public synchronized void isSyncA(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : isSyncA");
}
}catch (InterruptedException ie) {
}
}
public synchronized void isSyncB(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : isSyncB");
}
}catch (InterruptedException ie) {
}
}
public static synchronized void cSyncA(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : cSyncA");
}
}catch (InterruptedException ie) {
}
}
public static synchronized void cSyncB(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : cSyncB");
}
}catch (InterruptedException ie) {
}
}
}
public class LockTest2 {
Something x = new Something();
Something y = new Something();
// (02) x.isSyncA() y.isSyncA()
private void test2() {
// t21, t21 x.isSyncA()
Thread t21 = new Thread(
new Runnable() {
@Override
public void run() {
x.isSyncA();
}
}, "t21");
// t22, t22 x.isSyncB()
Thread t22 = new Thread(
new Runnable() {
@Override
public void run() {
y.isSyncA();
}
}, "t22");
t21.start(); // t21
t22.start(); // t22
}
public static void main(String[] args) {
LockTest2 demo = new LockTest2();
demo.test2();
}
}
t11 : isSyncA
t11 : isSyncA
t11 : isSyncA
t11 : isSyncA
t11 : isSyncA
t12 : isSyncB
t12 : isSyncB
t12 : isSyncB
t12 : isSyncB
t12 : isSyncB
// LockTest2.java
class Something {
public synchronized void isSyncA(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : isSyncA");
}
}catch (InterruptedException ie) {
}
}
public synchronized void isSyncB(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : isSyncB");
}
}catch (InterruptedException ie) {
}
}
public static synchronized void cSyncA(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : cSyncA");
}
}catch (InterruptedException ie) {
}
}
public static synchronized void cSyncB(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : cSyncB");
}
}catch (InterruptedException ie) {
}
}
}
public class LockTest2 {
Something x = new Something();
Something y = new Something();
// (02) x.isSyncA() y.isSyncA()
private void test2() {
// t21, t21 x.isSyncA()
Thread t21 = new Thread(
new Runnable() {
@Override
public void run() {
x.isSyncA();
}
}, "t21");
// t22, t22 x.isSyncB()
Thread t22 = new Thread(
new Runnable() {
@Override
public void run() {
y.isSyncA();
}
}, "t22");
t21.start(); // t21
t22.start(); // t22
}
public static void main(String[] args) {
LockTest2 demo = new LockTest2();
demo.test2();
}
}
t21 : isSyncA
t22 : isSyncA
t21 : isSyncA
t22 : isSyncA
t21 : isSyncA
t22 : isSyncA
t21 : isSyncA
t22 : isSyncA
t21 : isSyncA
t22 : isSyncA
// LockTest3.java
class Something {
public synchronized void isSyncA(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : isSyncA");
}
}catch (InterruptedException ie) {
}
}
public synchronized void isSyncB(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : isSyncB");
}
}catch (InterruptedException ie) {
}
}
public static synchronized void cSyncA(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : cSyncA");
}
}catch (InterruptedException ie) {
}
}
public static synchronized void cSyncB(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : cSyncB");
}
}catch (InterruptedException ie) {
}
}
}
public class LockTest3 {
Something x = new Something();
Something y = new Something();
// (03) x.cSyncA() y.cSyncB()
private void test3() {
// t31, t31 x.isSyncA()
Thread t31 = new Thread(
new Runnable() {
@Override
public void run() {
x.cSyncA();
}
}, "t31");
// t32, t32 x.isSyncB()
Thread t32 = new Thread(
new Runnable() {
@Override
public void run() {
y.cSyncB();
}
}, "t32");
t31.start(); // t31
t32.start(); // t32
}
public static void main(String[] args) {
LockTest3 demo = new LockTest3();
demo.test3();
}
}
t31 : cSyncA
t31 : cSyncA
t31 : cSyncA
t31 : cSyncA
t31 : cSyncA
t32 : cSyncB
t32 : cSyncB
t32 : cSyncB
t32 : cSyncB
t32 : cSyncB
// LockTest4.java
class Something {
public synchronized void isSyncA(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : isSyncA");
}
}catch (InterruptedException ie) {
}
}
public synchronized void isSyncB(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : isSyncB");
}
}catch (InterruptedException ie) {
}
}
public static synchronized void cSyncA(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : cSyncA");
}
}catch (InterruptedException ie) {
}
}
public static synchronized void cSyncB(){
try {
for (int i = 0; i < 5; i++) {
Thread.sleep(100); // 100ms
System.out.println(Thread.currentThread().getName()+" : cSyncB");
}
}catch (InterruptedException ie) {
}
}
}
public class LockTest4 {
Something x = new Something();
Something y = new Something();
// (04) x.isSyncA() Something.cSyncA()
private void test4() {
// t41, t41 x.isSyncA()
Thread t41 = new Thread(
new Runnable() {
@Override
public void run() {
x.isSyncA();
}
}, "t41");
// t42, t42 x.isSyncB()
Thread t42 = new Thread(
new Runnable() {
@Override
public void run() {
Something.cSyncA();
}
}, "t42");
t41.start(); // t41
t42.start(); // t42
}
public static void main(String[] args) {
LockTest4 demo = new LockTest4();
demo.test4();
}
}
t41 : isSyncA
t42 : cSyncA
t41 : isSyncA
t42 : cSyncA
t41 : isSyncA
t42 : cSyncA
t41 : isSyncA
t42 : cSyncA
t41 : isSyncA
t42 : cSyncA
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
자바 기본 튜토리얼 양보 자바 다중 튜토리얼1. yield() 소개 yield()의 역할은 양보입니다.이것은 현재 스레드가'실행 상태'에서'준비 상태'로 들어가서 같은 우선순위를 가진 다른 대기 스레드가 실행권을 얻도록 할 수 있다.단, 현재 스레드가 yie...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
