子线程循环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次,如此循环50次)

/** * 传统线程通信(子线程运行10次,主线程运行100次,如此循环50次) * @author 谭飞 * @date 2012-02-02 */ public class Tr...

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

public class ThreadTest { /** * @param args */ public static void main(String[] args) { ...

Java多线程面试题:子线程循环10次,接着主线程循环100,接着又回到子线程循环10次, 接着再回到主线程又循环100,如此循环50次

近在学习多线程,特贴在这里,并附上自己所作答案(参考与张孝祥老师的方法)。 题目如下: 子线程循环10次,接着主线程循环100,接着又回到子线程循环10次, 接着再回到主线程又循环100,...

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

package com.view04.alternate.print;/** * 子线程循环10次,主线程接着循环100次,如此循环50次的问题 * @author zhaojw_420 * */ p...

java一道多线程题,子线程循环10次,主线程接着循环100次,如此循环50次的问题

/** * 实现功能:子线程循环10次,接着主线程循环15次,接着又回到子线程循环10次,接着再回到主线程又循环15次,如此循环50次。 * @author elaine * */ publi...

主线程和子线程均循环10次,两者交替运行50次

我们应该时时保持面向对象编程的思想,可以将主子线程封装到一个类中(类中的方法是两个有关联的方法) ,使用标记变量可以人为的控制线程的执行。 import java.util.ArrayList; ...

多线程面试题:子线程循环10次,接着主线程循环100次;接着回到子线程循环10次,然后再回到主线程循环100次,如此交替50次。

public static void main(String[] args){ final Business b = new Business(); new Thread(){ @Overri...

(13)多线程与并发库之java5阻塞队列(BlockingQueue)的应用----子线程循环10次,接着主线程循环100次,接着又回到子线程循环10次,接着再回到主线程循环100次,如此循环50次

首先复习一下: 1,内部类的实例方法不能在静态中创建。 2,成员变量 在什么情况情况下才有值啊?在创建了类的实例对象的时候,才分配空间。这时,就需要一个构造方法来进行赋值。 3,st...

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

public class ThreadTest { /** * * 子线程循环10次,接着主线程循环5次,接着又回到子线程循环10次,接着再回到主线程又循环5次,如此循环50次...

张孝祥并发章节-子线程和主线程往复循环(学习笔记)

要求: 子线程先循环10次,然后主线程循环100次,然后子线程循环10次,接着主线程循环100次......如此往复50次。 代码: package cn.javaious.concurre...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:子线程循环10次,接着主线程循环100,接着又回到子线程循环10次,接着再回到主线程又循环100,如此循环50次
举报原因:
原因补充:

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