java多线程顺序输出ABCD

最新推荐文章于 2025-06-29 12:07:04 发布

转载最新推荐文章于 2025-06-29 12:07:04 发布 · 600 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/poeticliving/p/3240523.html

文章标签：

#java

本文介绍了一个使用Java实现的多线程同步示例，通过四个线程分别向公共字符数组中按顺序写入A、B、C、D，确保输出符合预期的ABCD序列。文章提供了完整的代码实现，并通过单元测试验证了程序的正确性。

问题描述：有4个线程和1个公共的字符数组。线程1的功能就是向数组输出A，线程2的功能就是向字符输出B，线程3的功能就是向数组输出C，线程4的功能就是向数组输出D。要求按顺序向数组赋值ABCDABCDABCD，ABCD的个数由线程函数1的参数指定。

代码如下：

package huawei;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
 * 
 */
public class Demo extends Thread{
    private static String tmp ;
     private static Lock lock = new ReentrantLock();
     private static int state =0;
     static boolean flag;   

    public static String multiThreadWrite(final int times) {
            tmp =new String();
            flag=false;
         Thread threadA =new Thread()
         {
             public void run(){
                 int count =0;
                
                 while(count<times)
                    {
                    lock.lock();
                    if(state%4==0)
                    {
                
                    tmp += "A";
                    state++;
                    count++;
                    }
                    lock.unlock();
                    }
                 
         }
         };
         
    
             Thread threadB =new Thread()
         {
            
             public void run(){
                 int count =0;
                
                  while(count<times)
                    {

                      
                    lock.lock();
                    if(state%4==1)
                    {
                        
                    tmp += "B";
                    state++;
                    count++;
                    }
                    lock.unlock();
                    }
                 
         }
         };
         
             Thread threadC =new Thread()
         {
             public void run(){
                 int count=0;
                
                 while(count<times)
                    {
                    lock.lock();
                    if(state%4==2)
                    {
                    tmp += "C";
                    state++;
                    count++;
                    }
                    lock.unlock();
                    }
                 
         }
         };
         
             Thread threadD =new Thread()
         {
            
             public void run()
             {
                 int count =0;
            
                    while(count<times)
                    {
                    lock.lock();
                    if(state%4==3)
                    {
                    tmp += "D";
                    state++;
                    count++;
                    }
                    lock.unlock();
                    }
                     flag=true;
            }
         };
         
         threadA.start();
         threadB.start();
         threadC.start();
         threadD.start();
         while(!flag); //防止main线程在四个线程执行完之前就返回tmp值
     return tmp; 
    }
}

View Code

测试代码：

package testcase;

import huawei.Demo;
import junit.framework.TestCase;

public class DemoTest extends TestCase {
    
    private void execTestCase(int num) {
        String rst = Demo.multiThreadWrite(num);
        
        String seed = "ABCD";
        String chk = new String();
        for (int i = 0; i < num; i ++) {
            chk += seed;
        }
        assertEquals(chk, rst);
    }
    
    public void testCase01() {
        execTestCase(1);
    }
    
    public void testCase03() {
        execTestCase(15);
    }
    
}