同步异步实例与应用场景，并发的实例及应用场景

最新推荐文章于 2023-09-03 12:59:42 发布

csdn_980979768

最新推荐文章于 2023-09-03 12:59:42 发布

阅读量618

点赞数

分类专栏： java 并发程序猿文章标签： Java 同步异步多线程并发

本文链接：https://blog.csdn.net/CSDN_980979768/article/details/103861543

版权

java 同时被 3 个专栏收录

26 篇文章 0 订阅

订阅专栏

并发

4 篇文章 0 订阅

订阅专栏

程序猿

2 篇文章 0 订阅

订阅专栏

本文通过实例展示了Java中同步异步的概念及其在多线程环境下的应用。通过ThreadA、ThreadB类的实现，演示了同步锁的使用，以及ThreadSyncA和ThreadSyncB类中简单的同步方法，探讨了并发执行和同步执行的场景。

摘要由CSDN通过智能技术生成

package com.hi.test;

public class Tools {

   // 如果数据存在共享的，那么为了保证数据的完全性，需要使用同步
   // 如果数据不存在的共享的问题，那么可以使用异步，使用并发执行

   public static ThreadLocal<String> t1 = new ThreadLocal<String>();

   public static ThreadLocal<Integer> t = new ThreadLocal<Integer>();

   public static int total = 1;

   public static Object lock = new Object();

   public static void main(String[] args) {

       new ThreadA(lock).start();

       new ThreadB(lock).start();

       new ThreadSyncA().start();

       new ThreadSyncB().start();

       synchronized (lock)
       {
           for(int i=0;i<100;i++)
           {
               t1.set("Main =" + (i+1));
               System.out.println("Value=" + Tools.t1.get() + " total=" + total);
               t.set(1);

               int val = Integer.parseInt("" +Tools.t.get());

               total += val;

               try
               {
                   Thread.sleep(60);
               }
               catch (InterruptedException e)
               {
                   e.printStackTrace();
               }
           }
       }
   }
}

===== ThreadA class ①

class ThreadA extends Thread{

   private Object lock;

   public ThreadA(Object lock)
   {
       this.lock = lock;
   }

   @Override
   public void run()
   {
       synchronized (lock)
       {
           for(int i=0;i<100;i++)
           {
               Tools.t1.set("ThreadA=" + (i+1));
               System.out.println("Value=" + Tools.t1.get() + " total=" + Tools.total);
               Tools.t.set(1);

               int val = Integer.parseInt(""+Tools.t.get());

               Tools.total += val;

               try
               {
                   Thread.sleep(60);
               }
               catch (InterruptedException e)
               {
                   e.printStackTrace();
               }
           }
       }
   }
}

===== ThreadA class ②

class ThreadB extends Thread{

   private Object lock;

   public ThreadB(Object lock)
   {
       this.lock = lock;
   }

   @Override
   public synchronized void run()
   {
       synchronized (lock)
       {
           for(int i=0;i<100;i++)
           {
               Tools.t1.set("ThreadB=" + (i+1));
               System.out.println("Value=" + Tools.t1.get() + " total=" + Tools.total);
               Tools.t.set(1);

               int val = Integer.parseInt(""+Tools.t.get());

               Tools.total += val;

               try
               {
                   Thread.sleep(60);
               }
               catch (InterruptedException e)
               {
                   e.printStackTrace();
               }
           }
       }
   }
}

====ThreadSyncA ③

class ThreadSyncA extends Thread{

   @Override
   public void run()
   {
       int total = 0;

       for(int i=0;i<100;i++)
       {
           System.out.println("begin Sync Method ThreadName =>" + Thread.currentThread().getName());

           total += 1;

           System.out.println("after Sync Method ThreadName =>" + Thread.currentThread().getName());
       }
       System.out.println("ThreadName="+ Thread.currentThread().getName()+" total=" + total);
   }
}

==== ThreadSync ④

class ThreadSyncB extends Thread{

   @Override
   public void run()
   {
       int total = 0;

       for(int i=0;i<100;i++)
       {
           System.out.println("begin Sync Method ThreadName =>" + Thread.currentThread().getName());

           total += 1;

           System.out.println("after Sync Method ThreadName =>" + Thread.currentThread().getName());
       }
       System.out.println("ThreadName="+ Thread.currentThread().getName() +" total=" + total);
   }
}