子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次

转载 2015年11月20日 22:52:03

第一种:

package thread;


public class TreadTest {

	public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        new TreadTest().init();  
  
    }  
  
    public void init(){  
        final Business business = new Business();  
        new Thread(  
                new Runnable()  
                {  
  
                    public void run() {  
                        for(int i=0;i<50;i++)  
                        {  
                            business.SubThread(i);  
                            System.out.println("循环"+i+"次");
                        }                         
                    }  
                      
                }  
          
        ).start();  
          
        for(int i=0;i<50;i++)  
        {  
            business.MainThread(i);  
        }         
    }  
      
    private class Business  {  
        boolean bShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯  
        public synchronized void MainThread(int i)  
        {  
            if(bShouldSub)  
                try {  
                    this.wait();  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }         
                  
            for(int j=0;j<5;j++)  
            {  
                System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);  
            }  
            bShouldSub = true;  
            this.notify();  
          
        }  
          
          
        public synchronized void SubThread(int i)  
        {  
            if(!bShouldSub)  
                try {  
                    this.wait();  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }     
                  
            for(int j=0;j<10;j++)  
            {  
                System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);  
            }  
            bShouldSub = false;               
            this.notify();            
        }  
    }  
}

第二种:

package thread;

import java.util.concurrent.Executors;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
import java.util.concurrent.locks.Condition; 

public class CurrentThread {

	private static Lock lock = new ReentrantLock();  
    private static Condition subThreadCondition = lock.newCondition();  
    private static boolean bBhouldSubThread = false;  
    public static void main(String [] args){  
        ExecutorService threadPool = Executors.newFixedThreadPool(3);  
        threadPool.execute(new Runnable(){  
            public void run(){  
                for(int i=0;i<50;i++) {  //子线程循环次数 50
                	System.out.println("子线程循环第"+i+"次");
                    lock.lock();                      
                    try {                     
                        if(!bBhouldSubThread)  
                            subThreadCondition.await();  
                        for(int j=0;j<10;j++) {  //子线程执行次数 10
                            System.out.println(Thread.currentThread().getName() + ",j=" + j);  
                        }  
                        bBhouldSubThread = false;  
                        subThreadCondition.signal();  
                    }catch(Exception e){                         
                    }  
                    finally {  
                        lock.unlock();  
                       
                    }  
                }      
            }  
              
        });  
        threadPool.shutdown();  
        for(int i=0;i<50;i++) { //循环的次数 50 
        	System.out.println("主线程循环第"+i+"次");
                lock.lock();                      
                try {     
                    if(bBhouldSubThread)subThreadCondition.await();                               
                    for(int j=0;j<100;j++){ //主线程执行次数 100  
                        System.out.println(Thread.currentThread().getName() + ",j=" + j);  
                    }  
                    bBhouldSubThread = true;  
                    subThreadCondition.signal();                      
                }catch(Exception e){                         
                }  
                finally {  
                    lock.unlock();  
                    
                }                     
        }  
    }  
}

作者 链接:http://blog.csdn.net/nszkadrgg/article/details/8197555


子线程循环10次,接着主线程循环100次,接着又回到子线程循环10次,接着再回到主线程100次,如此循环50次

public class ThreadCommunication { public static void main(String[] args) { final Business busine...
  • lhl19931026
  • lhl19931026
  • 2014年11月06日 09:47
  • 793

子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次,请写出程序

子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次,请写出程序...
  • qq442270636
  • qq442270636
  • 2017年06月22日 07:48
  • 544

子线程循环10次,接着主线程循环5次,接着又回到子线程循环10次,接着再回到主线程又循环5次,如此循环50次,请写出程序。

public class ThreadTest { /** * * 子线程循环10次,接着主线程循环5次,接着又回到子线程循环10次,接着再回到主线程又循环5次,如此循环50次...
  • zheng0518
  • zheng0518
  • 2014年03月21日 14:48
  • 953

多线程学习--案例-子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次

子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次,请写出程序。  package Demo4; public cla...
  • u014469072
  • u014469072
  • 2015年11月16日 15:18
  • 279

多线程经典问题2——子线程之间交替问题

编写一个程序,开启3个线程,这3个线程的ID分别为A、B、C,每个线程将自己的ID在屏幕上打印10遍,要求输出结果必须按ABC的顺序显示;如:ABCABC….依次递推。 这个问题仍旧是线程间的交替控...
  • u011680348
  • u011680348
  • 2015年08月13日 09:19
  • 803

子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次.

public class ThreadTest { /** * @param args */ public static void main(String[] args) { ...
  • nszkadrgg
  • nszkadrgg
  • 2012年11月18日 22:47
  • 5008

子线程循环10次,紧接着主线程循环100次,来回50次

package cn.test.thread; /* * 子线程10次,主线程100次,来回50次 */ public class ThreadTest1 { public static v...
  • z83986976
  • z83986976
  • 2015年05月11日 16:55
  • 1653

java多线程: 子线程循环10次,主线程接着循环100次,如此循环50次

package com.view04.alternate.print;/** * 子线程循环10次,主线程接着循环100次,如此循环50次的问题 * @author zhaojw_420 * */ p...
  • zhaojw_420
  • zhaojw_420
  • 2017年04月01日 00:21
  • 732

子线程循环 10 次,接着主线程循环 100 次,接着又回到子线程循环10 次(线程面试:windows下实现)

浏览MoreWindows的文章写出来的http://blog.csdn.net/morewindows/article/details/7392749  #include #include...
  • lilien1010
  • lilien1010
  • 2012年10月27日 15:15
  • 4426

子线程循环 10 次,接着主线程循环 100 次,接着又回到子线程循环 10 次,接着再回到主线程又循环 100 次,如此循环50次,试写出代码。

HANDLE thread_semaphore; HANDLE main_handle ; unsigned int WINAPI fun(LPVOID pm); const int times = ...
  • evanbao
  • evanbao
  • 2014年08月31日 17:25
  • 525
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次
举报原因:
原因补充:

(最多只允许输入30个字)