JAVA基础：Java多线程同步问题

会计考友

Java多线程的同步依靠的是对象锁机制，synchronized关头字的背后就是操作了封锁来实现对共享资本的互斥访谒。
   
3 c3 B& z4 T, v. t  D: N/ r2 p/ ~    下面以一个简单的实例来进行对比剖析。实例要完成的工作很是简单，就是建树10个线程，每个线程都打印从0到99这100个数字，我们但愿线程之间不会呈现交叉乱序打印，而是挨次地打印。
1 ~3 l9 F0 a3 B1 w   
    先来看第一段代码，这里我们在run（）体例中插手了synchronized关头字，但愿能对run体例进行互斥访谒，但结果并不如我们但愿那样，这是因为这里synchronized锁住的是this对象，即当前运行线程对象自己。代码中建树了10个线程，而每个线程都持有this对象的对象锁，这不能实现线程的同步。
4 G) A4 ^* X' l6 E7 \; v5 V- L( a   
/ d2 g! W  F. V! k! h. {6 H) ]    代码
: q! K7 Q5 {3 u$ x8 x$ Q   
4 ~. V7 `, B6 z) ^( d    package com.vista;
   
$ Q) x' u- r! N/ ~8 c1 e    class MyThread implements java.lang.Runnable {
( [3 w) k  T0 e, @   
8 e+ U, _2 @# b9 o4 f( ~    private int threadId;
   
2 D5 y1 n9 P% O5 W; v! }( \( g    public MyThread（int id） {
   
    this.threadId = id;
   
! G: ~: R, p3 E. a6 V    }
- b  T. \* u$ h" l! z9 L8 H   
) t; a) I4 Z* b4 j$ C# c    @Override
   
" N0 ~, {0 n1 k( {( U! i8 K5 U- V    public synchronized void run（） {
, Q! x; W# s: A+ |* F9 @/ k   
    for （int i = 0; i 《 100; ++i） {
. M/ @) z# A" ?5 }/ V2 H& A+ q) W   
    System.out.println（"Thread ID: " + this.threadId + " : " + i）；
   
, L" J1 p+ K+ T/ H0 T, @; w- |1 K    }
) K9 t7 L0 l6 C7 |; t$ T, w1 g   
    }
   
    }

会计考友

public class ThreadDemo {
- y7 }" a3 r+ C, P& X. l   
    /**
   
    * @param args
   
    * @throws InterruptedException
   
2 d" i. x( D/ X    */
   
    public static void main（String[] args） throws InterruptedException {
- p5 f! G6 ?2 G: C5 N. G   
    for （int i = 0; i 《 10; ++i） {
3 ]- L% g! G# J! x! U   
    new Thread（new MyThread（i））。start（）；
   
# D% h0 T8 D. j) m. |    Thread.sleep（1）；
5 {; N( ^8 ?) {8 f5 P+ R6 @6 h   
: {( j* t, W- }) t3 V" D) L3 j    }
   
    }
+ n2 |! {6 B4 e& Q, g   
4 w, t/ p4 w. ~: Z/ |  }/ z    }
   
& r- ^5 e( G! Z, l6 k4 r$ L    从上述代码段可以得知，要想实现线程的同步，则这些线程必需去竞争一个独一的共享的对象锁。
   
    基于这种思惟，我们将第一段代码改削如下所示，在建树启动线程之前，先建树一个线程之间竞争使用的Object对象，然后将这个Object对象的引用传递给每一个线程对象的lock成员变量。这样一来，每个线程的lock成员都指向统一个Object对象。我们在run体例中，对lock对象使用synchronzied块进行局部封锁，这样就可以让线程去竞争这个独一的共享的对象锁，从而实现同步。
6 a2 R* q7 M3 v7 D   
2 ]: r. R1 {$ `/ t, d  u2 m7 `" h; Q    代码
# O& v# L: Y" `% x  v! O   
, j9 ^1 K! _2 _8 F6 k    package com.vista;
   
    class MyThread implements java.lang.Runnable {
   
    private int threadId;
8 g. a; d4 ~. ^% [9 }; j2 J1 t9 q) E   
: L3 I' H+ w$ z! F3 v- x    private Object lock;
   
: y  X; K3 e' Y% J* A( Q3 y0 n    public MyThread（int id, Object obj） {
   
    this.threadId = id;
   
    this.lock = obj;
, q: v; e# \% K9 P+ q7 h   
    }

会计考友

@Override
   
    public void run（） {
   
0 `4 u+ U# L) B    synchronized （lock） {
3 p# `! D8 P5 d+ W8 z   
# b. u, ^5 G3 P    for （int i = 0; i 《 100; ++i） {
   
; C. u0 q4 D+ T5 X! ]$ \    System.out.println（"Thread ID: " + this.threadId + " : " + i）；
- b" K! f. h0 q% B   
; x4 W+ j7 W, q7 K% S1 `1 I    }
   
( j) e' d( p3 f& o# h4 `    }
   
& c! r8 C( i, I5 g$ z; T6 S' K    }
+ j7 `9 N3 u' R& L+ L   
    }
& D& L! b, w3 P& `4 u/ m: q   
    public class ThreadDemo {
   
    /**
   
    * @param args
( j5 F) R- L. G- J+ w   
    * @throws InterruptedException
   
    */
& M* }9 a+ w7 a( [. v   
: J7 U4 \3 O* p  b, W0 a6 O( u& d    public static void main（String[] args） throws InterruptedException {
   
    Object obj = new Object（）；
) [4 Q, u  h* m7 _0 o9 l) S+ R   
    for （int i = 0; i 《 10; ++i） {
   
. Z6 [' s4 ?3 o7 C    new Thread（new MyThread（i, obj））。start（）；NnF365考试网