线程同步、线程的死锁问题(线程间同步)

java8

帖子摘要：线程同步模拟售票程序出现问题          当多个线程同时访问共享数据时产生无序、重复、超额售票等多线程安全问题解决将多个线程需要访问的共享数据包装起来视为一个整体确保一次只有一个线程执行流访......
  x; W' I0 \8 I+ J
大家好，欢迎来到Java吧（www.java8.com），交流、学习Java技术、获取Java资源无任何套路，今天说一说：“线程同步、线程的死锁问题”2 E3 ]5 I7 x4 q5 X1 K. m" H! }- s' L: F  @



                  线程同步
模拟售票程序出现问题
         当多个线程同时访问共享数据时产生无序、重复、超额售票等多线程安全问题
解决将多个线程需要访问的共享数据包装起来视为一个整体确保一次只有一个线程执行流访问共享数据
Java为上述问题提供了相应的解决办法
1、同步代码块
      synchronized(同步监视器){
         //多个线程需要访问的共享数据
      }
      同步监视器俗称“锁” 可以使用任意类型的对象充当。但是必须保证多个线程持有同一把锁同一个对象
2、同步方法
3、同步锁 Lock

package Thread;
public class TicketWindow2 implements Runnable{
  g0 ^) v1 E; a* [
    int tick=100;
* p7 H/ O! Z; V% d
    Object obj=new Object();
( k* k  S+ \) |2 X6 {
    @Override
2 J, b3 j% c* j) K9 s
    public void run() {
$ S5 z" Q) _* ]8 k1 j
        while (true){
            synchronized (obj){
                if (tick>0){
                    try {
                        Thread.sleep(100);
2 R' B) `; i6 C0 }
                    } catch (InterruptedException e) {
/ j+ e+ @9 s8 Y6 J; u7 a
                    }
                    System.out.println(Thread.currentThread().getName()+"完成售票剩余票数"+ --tick);
                }
            }
' @* C4 C/ o  J# E
        }
    }
9 ], B1 o0 |8 g8 {- j5 p4 T
}
1 Z9 A% a$ x+ B* Q
复制代码

package Thread;
public class TicketWindowTest2 {
    public static void main(String[] args) {
        TicketWindow2 tw2=new TicketWindow2();
( c- }6 _' m6 L6 y) U7 ?$ A- y: P
        Thread t1=new Thread(tw2,"一号窗口");
, `5 G% d. a7 q5 ^% h! U2 ]) ]
        t1.start();
5 l  @2 z' t$ L
        Thread t2=new Thread(tw2,"二号窗口");
3 [, _: m8 |$ _/ D8 S0 y: a( p$ `0 T
        t2.start();
  E; W7 j5 A* a$ U0 \
        Thread t3=new Thread(tw2,"三号窗口");
        t3.start();
0 f' H- l) `; i2 H7 J* q2 e7 D
    }
' Z& B7 _8 x7 k4 J3 B* F% v) g5 w% _
}
复制代码

86b6f2fc82bd426283daccf7c1504f74.png (78.28 KB, 下载次数: 0, 售价: 6 金钱)

2023-1-19 12:26 上传

点击文件名下载附件
86b6f2fc82bd426283daccf7c1504f74.png

同步方法

在方法声明处加 synchronized 关键字
            如
                  public synchronized void show() {
               }

package Thread;
% s8 e: @. K4 h5 x, L
public class TicketWindow2 implements Runnable{
    int tick=100;
9 E' m. m" ?+ s# a( G
    Object obj=new Object();
4 X5 o. B* K/ e; S, R' M
    @Override
    public void run() {
$ s1 Z% I: F  T0 k" A
        while (true){
           /* synchronized (obj){
                if (tick>0){
                    try {
                        Thread.sleep(100);
7 ]2 c- X: y/ V( H# E, K+ c9 B2 ?
                    } catch (InterruptedException e) {
                    }
                    System.out.println(Thread.currentThread().getName()+"完成售票剩余票数"+ --tick);
                }
            }*/
            show();
        }
  |- a; C5 `" p6 d  r( ^! `2 ~& ^
    }
    public synchronized void show(){
        if (tick>0){
* }3 w. w# ~( i% S. m7 [; d- K
            try {
% V; W) u* O  I4 \; O
                Thread.sleep(100);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread().getName()+"完成售票剩余票数"+ --tick);
1 z5 B: ^* \* C4 T2 T+ _, o
        }
2 R/ g; m! |/ O0 l; y
    }
}
+ q* D. m3 v5 l+ U: I; X% G
复制代码

同步锁

Lock为接口创建实例

d6316d992f56445d8ed4d8ca59b16c9d.png (45.98 KB, 下载次数: 0, 售价: 4 金钱)

2023-1-19 12:26 上传

点击文件名下载附件
d6316d992f56445d8ed4d8ca59b16c9d.png

unlock一定要执行所以放到try-catch-finally中

package Thread;
import java.util.concurrent.locks.Lock;
: @% G' ?/ y: O+ f
import java.util.concurrent.locks.ReentrantLock;
public class TicketWindow2 implements Runnable{
    int tick=100;
# m' E0 E2 ]  k) m! Y- @
    Object obj=new Object();
    Lock l=new ReentrantLock();
7 j( g0 I5 q6 v6 H
    @Override
    public void run() {
        while (true){
/ h" d1 Y, \5 |/ w" X9 c8 S0 k9 ]; ?
           /* synchronized (obj){
, N4 Z7 r. N$ J& R4 m% J- p, L, S0 I1 @
                if (tick>0){
                    try {
2 w4 U/ O  W; J2 v
                        Thread.sleep(100);
1 ~2 T$ m0 z( Y  \
                    } catch (InterruptedException e) {
                    }
                    System.out.println(Thread.currentThread().getName()+"完成售票剩余票数"+ --tick);
" J% K* m- w6 n+ R8 s0 k! \
                }
            }*/
  L% R4 l$ H; F5 t

* J+ U' f" m  z+ Q
//            show();
            l.lock();//上锁
            try {
                if (tick>0){
* P+ m! U! j, g7 o
                    try {
6 E1 l- k/ Q7 `$ [2 e7 |  K
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
' S) I  c* @% i0 _- c' Q; v
                    }
                    System.out.println(Thread.currentThread().getName()+"完成售票剩余票数"+ --tick);
                }
! g* _* B' k4 W  _  z: H
            } catch (Exception e) {
  {- L$ @/ I. b  ~4 F
                e.printStackTrace();
7 n: Y  ?* r5 h! n+ k
            } finally {
                l.unlock();//释放锁
% `/ v, G% m3 x1 c  B' m/ h5 S/ j
            }
        }
' n5 E& O8 j) \  i" L
    }
+ |& d. E& q" n" p* C
    public synchronized void show(){
& S- Z/ q# c; ~# |/ `; @
        if (tick>0){
            try {
4 |* ?; g$ p  v  z6 @# |
                Thread.sleep(100);
9 p9 C  W/ v4 D. x8 T% R- @
            } catch (InterruptedException e) {
% n7 i) L1 S) S; {# p
            }
            System.out.println(Thread.currentThread().getName()+"完成售票剩余票数"+ --tick);
! U( o! n% A  K$ S% [; R; t
        }
, g8 v, z; p1 [) s1 Z; q  v. `
    }
}
复制代码

84cc385cb5a846d0a3e7f3e73b5bd79d.png (203.57 KB, 下载次数: 0, 售价: 1 金钱)

2023-1-19 12:26 上传

点击文件名下载附件
84cc385cb5a846d0a3e7f3e73b5bd79d.png

当前的锁为悲观锁

线程同步
模拟售票程序出现问题
         当多个线程同时访问共享数据时产生无序、重复、超额售票等多线程安全问题
解决将多个线程需要访问的共享数据包装起来视为一个整体确保一次只有一个线程执行流访问共享数据
Java为上述问题提供了相应的解决办法
1、同步代码块
      synchronized(同步监视器){
         //多个线程需要访问的共享数据
      }
      同步监视器俗称“锁” 可以使用任意类型的对象充当。但是必须保证多个线程持有同一把锁同一个对象
2、同步方法在方法声明处加 synchronized 关键字
                  如
                     public synchronized void show() {
                  }
            注意非静态同步方法隐式的锁为 this即当前对象
                  静态同步方法的锁为对应类的Class实例
3、同步锁 Lock
Exer

银行有一个账户。
有两个储户分别向同一个账户存3000元每次存1000存3次。每次存完打印账户余额.
问题:该程序是否有安全问题如果有如何解决?
【提示】
1明确哪些代码是多线程运行代码须写入run()方法
2明确什么是共享数据。
3明确多线程运行代码中哪些语句是操作共享数据的。

package Exer;
- f/ s$ S& E1 z1 f
/*
银行有一个账户。
" y3 V. y' d+ P2 h6 b+ H7 Q8 u" O
有两个储户分别向同一个账户存3000元每次存1000存3次。每次存完打印账户余额.
问题:该程序是否有安全问题如果有如何解决?
; @' o8 `' }3 I9 ]1 q0 R
【提示】
1明确哪些代码是多线程运行代码须写入run()方法
& }$ v2 t0 b1 u+ u3 H  M
2明确什么是共享数据。|
3明确多线程运行代码中哪些语句是操作共享数据的。
* V- d5 L( v) L2 p2 n" J; U
 */
2 J, w7 G2 I, G. o7 `
public class Exer {
" M/ Z" ~6 a2 ~' ^: f; X5 s
    public static void main(String[] args) {
        Account account=new Account();
$ ?# A  m1 M" r: D& T+ L2 A
        Customer ca=new Customer(account);
        Customer cb=new Customer(account);
        new Thread(ca,"用户A").start();
' e2 \6 d" e5 H" P, v. K
        new Thread(cb,"用户B").start();
    }
}
2 q( F3 p6 X1 U. J; a1 D3 M
复制代码

package Exer;
public class Account {
/ a$ B$ _  V. J' B9 O
    private double balance;
    public Account() {
) h& o5 W( @. [+ T) G" @% h
    }
    public Account(double balance) {
        this.balance = balance;
; G) z1 s& A2 p7 V3 p3 f* A
    }
6 H$ i4 m4 t1 ]1 z" H% }. S* f
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
% f, ?; R% L/ H1 T: y+ m/ H
        this.balance = balance;
3 P/ d/ w" ?$ G3 G+ y: V8 I
    }
9 ]8 A& J' P' R1 }
    //存款
    public synchronized void deposit(double amount){
        balance+=amount;
        System.out.println(Thread.currentThread().getName()+"成功存入"+amount+"余额为"+balance);
    }
0 P5 I4 l, R6 j  E+ O2 M; r5 K& |7 y
}
复制代码

package Exer;
public class Customer implements Runnable {
    private Account account;
) f; V0 {; p2 B+ W9 Z7 s
    public Customer() {
    }
    public Customer(Account account) {
9 m. O" b  O: ]% d, {' d6 T
        this.account = account;
% ~6 j$ h) H1 l: X
    }
! i) X3 i- k. ~0 q
    public Account getAccount() {
        return account;
8 y5 m1 u( z. U" ]* m8 l
    }
2 Z# N. x% T+ Q/ g- E7 @
    public void setAccount(Account account) {
5 P7 C0 e' E9 b; N
        this.account = account;
    }
5 r, k9 i( ]3 n, W$ R5 v
    @Override
- o" s' g$ x! ~$ `4 u
    public void run() {
        for (int i = 0; i  







f037339948714dac9b4bfeea59553200.png

(46.41 KB, 下载次数: 0, 售价: 4 金钱)



2023-1-19 12:26 上传
点击文件名下载附件
f037339948714dac9b4bfeea59553200.png



 
+ Q1 k4 [" _1 H3 U5 o
 
2 H( l9 u- ^) j3 l; m' H$ q
 补充互斥锁
 
, p" S  N+ j* [7 `0 D  V







3e31651400b2415d99ee0fa7c101c854.png

(273.67 KB, 下载次数: 0, 售价: 3 金钱)



2023-1-19 12:26 上传
点击文件名下载附件
3e31651400b2415d99ee0fa7c101c854.png



 







d2a252e552bb4cf28e8f5fda2ba0c526.png

(271.92 KB, 下载次数: 0, 售价: 2 金钱)



2023-1-19 12:26 上传
点击文件名下载附件
d2a252e552bb4cf28e8f5fda2ba0c526.png



% s/ M& g9 y- Z; @7 v8 n
 
( S8 x1 c5 _9 s- O9 q9 m& H
 
% c4 M6 w. s1 _







23d14fdbed584213b089112fbc2c7a82.png

(284.68 KB, 下载次数: 0, 售价: 2 金钱)



2023-1-19 12:26 上传
点击文件名下载附件
23d14fdbed584213b089112fbc2c7a82.png



 
 
线程的死锁问题 
 
8 `4 T9 _1 a3 v3 q2 K% @  A







1a0c3ee17fb04c2a9fe17c7d6995c90a.png

(165.71 KB, 下载次数: 0, 售价: 4 金钱)



2023-1-19 12:26 上传
点击文件名下载附件
1a0c3ee17fb04c2a9fe17c7d6995c90a.png



/ V2 |4 x1 m4 a
 
 
: W& |4 V& f& H- S0 j2 n
 
 
[code]package Thread;
public class DeadLockTest {
    public static void main(String[] args) {
& q+ ?  b' c1 e; t4 X
        DeadLock dl=new DeadLock();
        new Thread(dl).start();
) Y/ D1 E$ o; r& S1 b
        new Thread(dl).start();
    }
. R+ \' X7 h: G2 u& K( k
}
class DeadLock implements  Runnable{
" H( L* x  k% ^  q# @
    boolean flag=true;
% W4 O5 X: F- b
    static Object obj1=new Object();//共享数据1
( E* p1 y7 s0 `5 F& {
    static Object obj2=new Object();//共享数据2
    @Override
3 x, m  D; N$ c8 U& c7 B2 G
    public void run() {
        if (flag){
( v  @( z9 t3 W' _; P& D& j/ F$ H$ F
            synchronized (obj1){
                System.out.println("获取共享数据1等待共享数据2....");
                synchronized (obj2){
                    System.out.println("-----------------------");
" j- C* ~1 b) V9 _6 f" j- A  W
                }
: W( K7 w: Y' `" [* ]. M# @
            }
3 y1 G0 Q* E* X7 d6 D. v
        }else {
            synchronized (obj2){
                System.out.println("获取共享数据2等待共享数据1....");
                synchronized (obj1){
                    System.out.println("*************************");
                }
1 A/ a" u4 n- ~* n1 a# c
            }
        }
    }
4 h# A+ X, e( x& n
}
复制代码

b4aac326696a47fea2cd7914a5b13dad.png (101.13 KB, 下载次数: 0, 售价: 3 金钱)

线 程 同 步、线程的死锁问题(线程间同步)

java8 LV9

线程同步、线程的死锁问题(线程间同步)