个人中心
gpt4 book ai didi

JAVA线程同步实例教程

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章JAVA线程同步实例教程由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

线程是Java程序设计里非常重要的概念，本文就以实例形式对此加以详细解读。具体分析如下:

首先，线程加锁有什么用处呢？举个例子：比如你现在有30000块大洋在银行存着，现在你到银行取钱，当你输入密码完成后，已经输入取款金额，比如你输入的是20000，就是在银行给你拿钱这个时刻，你老婆也去银行取这笔钱，你老婆同样取20000，因为此时你的账上仍然是30000，所以银行同样的操作在你老婆那端又进行了一遍，这样当你们两个完成各自操作后，银行记录的你账上还应该有10000块存款，这样是不是很爽。解决这个问题就用到了线程加锁的知识，下面就让我们一起来学习一下吧.

1、未处理线程同步的一个例子:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class TextSync implements Runnable{
   /**未处理线程同步
    * @param args
    */
   Time time = new Time();
   public static void main(String[] args) {
     TextSync text = new TextSync();
     Thread t1 = new Thread(text);
     Thread t2 = new Thread(text);
     t1.setName( "t1" );
     t2.setName( "t2" );
     t1.start();
     t2.start();
   }
   @Override
   public void run() {
     time.add(Thread.currentThread().getName());
   }
}
class Time {
   private static int num = 0 ;
   public void add(String name){
     try {
       num++;
       //当第一个线程执行到此时，num变成了1，第一个线程暂停一秒，
       //第二个线程开始执行，当第二个线程执行到此时，num变成了2，第二个线程暂停一秒，
       //第一个线程此时的num同样变成了2，所以最终的结果均为2；
       Thread.sleep( 1000 );
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
     System.out.println(name+ "是第" +num+ "个执行的线程。" );
   }
}

输出结果:

?
1
2
t2是第 2 个执行的线程。
t1是第 2 个执行的线程。

2、线程同步 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class TextSynctwo implements Runnable{
   /**线程同步
    * @param args
    */
   Time1 time = new Time1();
   public static void main(String[] args) {
     TextSynctwo text = new TextSynctwo();
     Thread t1 = new Thread(text);
     Thread t2 = new Thread(text);
     t1.setName( "t1" );
     t2.setName( "t2" );
     t1.start();
     t2.start();
   }
   @Override
   public void run() {
     time.add(Thread.currentThread().getName());
   }
}
class Time1 {
   private static int num = 0 ;
  
   //synchronized锁定当前线程，可以在方法定义时进行声明，或采用在方法中进行设置。
   public synchronized void add(String name){
     //synchronized (this) {//锁定当前线程，防止此时被别的线程执行
       try {
         num++;
         Thread.sleep( 1000 );
       } catch (InterruptedException e) {
         e.printStackTrace();
       }
       System.out.println(name+ "是第" +num+ "个执行的线程。" );
     //}
   }
}

输出结果:

?
1
2
t1是第 1 个执行的线程。
t2是第 2 个执行的线程。

3、死锁 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class TestDeadLock implements Runnable{
   /**死锁
    * @param args
    */
   private int flag = 0 ;
   static Object o1 = new Object();
   static Object o2 = new Object();
   public static void main(String[] args) {
     TestDeadLock td1 = new TestDeadLock();
     TestDeadLock td2 = new TestDeadLock();
     td1.flag = 1 ;
     td2.flag = 2 ;
     Thread t1 = new Thread(td1);
     Thread t2 = new Thread(td2);
     t1.setName( "t1" );
     t2.setName( "t2" );
     t1.start();
     t2.start();
   }
 
   @Override
   public void run() {
     System.out.println(Thread.currentThread().getName());
     if (flag == 1 ){
       synchronized (o1){
         try {
           Thread.sleep( 5000 );
         } catch (InterruptedException e) {
           e.printStackTrace();
         }
         synchronized (o2){
           System.out.println( "1" );
         }
       }
     }
     if (flag == 2 ){
       synchronized (o2){
         try {
           Thread.sleep( 5000 );
         } catch (InterruptedException e) {
           e.printStackTrace();
         }
         synchronized (o1){
           System.out.println( "2" );
         }
       }
     }
   }
}

4、锁定 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class TT implements Runnable{
   /**锁定
    * @param args
    */
   int b = 100 ;
   public static void main(String[] args) {
     TT tt = new TT();
     Thread th = new Thread(tt);
     th.start();
     try {
       tt.m2();
     } catch (Exception e) {
       e.printStackTrace();
     }
     System.out.println(tt.b);
   }
   @Override
   public void run() {
     try {
       m1();
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
   private synchronized void m1() throws Exception{
     b = 1000 ;
     Thread.sleep( 5000 );
     System.out.println( "b=" +b);
   }
   private synchronized void m2() throws Exception{
     Thread.sleep( 2500 );
     b = 2500 ;
   }
}

现在的输出结果是:

?
1
2
1000
b= 1000

可见这里m2先执行，m1要等m2执行完毕后方可执行.

希望本文所述对大家的Java程序设计有所帮助 。

最后此篇关于JAVA线程同步实例教程的文章就讲到这里了,如果你想了解更多关于JAVA线程同步实例教程的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： 如何彻底删除SVN中的文件和文件夹(附恢复方法)
文章推荐： Spring中DAO被循环调用的时候数据不实时更新的解决方法
文章推荐： 初识JAVA数组
文章推荐： JAVA线程用法详解
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com