面试题--三个线程循环打印ABC10次的几种解决方法

最新推荐文章于 2024-08-12 00:17:43 发布
最新推荐文章于 2024-08-12 00:17:43 发布
阅读量1w 收藏 22
点赞数 2
分类专栏： java技术
最近发现公司有份笔试试卷中有道多线程的题目：有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…

这个最早好像是迅雷的面试题目吧，看到了然后就想重温一下这个题目的解决方法。

在本文中，给出了五种这个题目的解决方法：

  • 使用sleep
  • 使用synchronized, wait和notifyAll
  • 使用Lock 和 Condition
  • 使用Semaphore
  • 使用AtomicInteger


下面依次给出每种解决方案的代码：

使用sleep
Java代码
  1. package my.thread.test;   
  2.   
  3. /**  
  4.  * @author Eric  
  5.  */  
  6. public class SleepExample extends Thread {   
  7.   
  8.     private static int currentCount = 0;   
  9.   
  10.     public SleepExample(String name) {   
  11.         this.setName(name);   
  12.     }   
  13.   
  14.     @Override  
  15.     public void run() {   
  16.         while (currentCount < 30) {   
  17.             switch (currentCount % 3) {   
  18.             case 0:   
  19.                 if ("A".equals(getName())) {   
  20.                     printAndIncrease();   
  21.                 }   
  22.                 break;   
  23.             case 1:   
  24.                 if ("B".equals(getName())) {   
  25.                     printAndIncrease();   
  26.                 }   
  27.                 break;   
  28.             case 2:   
  29.                 if ("C".equals(getName())) {   
  30.                     printAndIncrease();   
  31.                 }   
  32.                 break;   
  33.             }   
  34.         }   
  35.   
  36.     }   
  37.   
  38.     private void printAndIncrease() {   
  39.         print();   
  40.         increase();   
  41.     }   
  42.   
  43.     private void print() {   
  44.         System.out.println(getName());   
  45.         if ("C".equals(getName())) {   
  46.             System.out.println();   
  47.         }   
  48.     }   
  49.   
  50.     private void increase() {   
  51.         currentCount++;   
  52.     }   
  53.   
  54.     public static void main(String[] args) {   
  55.         new SleepExample("A").start();   
  56.         new SleepExample("B").start();   
  57.         new SleepExample("C").start();   
  58.     }   
  59.   
  60. }  
<span style="font-family:KaiTi_GB2312;font-size:18px;">package my.thread.test;

/**
 * @author Eric
 */
public class SleepExample extends Thread {

	private static int currentCount = 0;

	public SleepExample(String name) {
		this.setName(name);
	}

	@Override
	public void run() {
		while (currentCount < 30) {
			switch (currentCount % 3) {
			case 0:
				if ("A".equals(getName())) {
					printAndIncrease();
				}
				break;
			case 1:
				if ("B".equals(getName())) {
					printAndIncrease();
				}
				break;
			case 2:
				if ("C".equals(getName())) {
					printAndIncrease();
				}
				break;
			}
		}

	}

	private void printAndIncrease() {
		print();
		increase();
	}

	private void print() {
		System.out.println(getName());
		if ("C".equals(getName())) {
			System.out.println();
		}
	}

	private void increase() {
		currentCount++;
	}

	public static void main(String[] args) {
		new SleepExample("A").start();
		new SleepExample("B").start();
		new SleepExample("C").start();
	}

}</span>


使用synchronized, wait和notifyAll

Java代码 复制代码
  1. package my.thread.test;   
  2.   
  3. import java.util.concurrent.ExecutorService;   
  4. import java.util.concurrent.Executors;   
  5.   
  6. public class PrintThreadExample {   
  7.   
  8.     public static void main(String[] args) {   
  9.         PrintThreadExample example = new PrintThreadExample();   
  10.   
  11.         LetterPrinter letterPrinter = example.new LetterPrinter();   
  12.   
  13.         ExecutorService service = Executors.newFixedThreadPool(3);   
  14.   
  15.         service.execute(example.new PrintRunnable(letterPrinter, 'A'));   
  16.         service.execute(example.new PrintRunnable(letterPrinter, 'B'));   
  17.         service.execute(example.new PrintRunnable(letterPrinter, 'C'));   
  18.   
  19.         service.shutdown();   
  20.     }   
  21.   
  22.     private class LetterPrinter {   
  23.         private char letter = 'A';   
  24.   
  25.         public void print() {   
  26.             System.out.println(letter);   
  27.             if ('C' == letter) {   
  28.                 System.out.println();   
  29.             }   
  30.         }   
  31.   
  32.         public void nextLetter() {   
  33.             switch (letter) {   
  34.             case 'A':   
  35.                 letter = 'B';   
  36.                 break;   
  37.             case 'B':   
  38.                 letter = 'C';   
  39.                 break;   
  40.             case 'C':   
  41.                 letter = 'A';   
  42.                 break;   
  43.             }   
  44.         }   
  45.   
  46.         /**  
  47.          * @return the letter  
  48.          */  
  49.         public char getLetter() {   
  50.             return letter;   
  51.         }   
  52.   
  53.     }   
  54.   
  55.     private class PrintRunnable implements Runnable {   
  56.   
  57.         private LetterPrinter letterPrinter = null;   
  58.   
  59.         private char letter = ' ';   
  60.   
  61.         /**  
  62.          * @param letterPrinter  
  63.          * @param letter  
  64.          */  
  65.         public PrintRunnable(LetterPrinter letterPrinter, char letter) {   
  66.             super();   
  67.             this.letterPrinter = letterPrinter;   
  68.             this.letter = letter;   
  69.         }   
  70.   
  71.         public void run() {   
  72.             for (int i = 0; i < 10; i++) {   
  73.                 synchronized (letterPrinter) {   
  74.                     while (letter != letterPrinter.getLetter()) {   
  75.                         try {   
  76.                             letterPrinter.wait();   
  77.                         } catch (InterruptedException e) {   
  78.                             // TODO Auto-generated catch block   
  79.                             e.printStackTrace();   
  80.                         }   
  81.                     }   
  82.   
  83.                     letterPrinter.print();   
  84.                     letterPrinter.nextLetter();   
  85.                     letterPrinter.notifyAll();   
  86.   
  87.                 }   
  88.             }   
  89.   
  90.         }   
  91.   
  92.     }   
  93.   
  94. }  
<span style="font-family:KaiTi_GB2312;font-size:18px;">package my.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PrintThreadExample {

	public static void main(String[] args) {
		PrintThreadExample example = new PrintThreadExample();

		LetterPrinter letterPrinter = example.new LetterPrinter();

		ExecutorService service = Executors.newFixedThreadPool(3);

		service.execute(example.new PrintRunnable(letterPrinter, 'A'));
		service.execute(example.new PrintRunnable(letterPrinter, 'B'));
		service.execute(example.new PrintRunnable(letterPrinter, 'C'));

		service.shutdown();
	}

	private class LetterPrinter {
		private char letter = 'A';

		public void print() {
			System.out.println(letter);
			if ('C' == letter) {
				System.out.println();
			}
		}

		public void nextLetter() {
			switch (letter) {
			case 'A':
				letter = 'B';
				break;
			case 'B':
				letter = 'C';
				break;
			case 'C':
				letter = 'A';
				break;
			}
		}

		/**
		 * @return the letter
		 */
		public char getLetter() {
			return letter;
		}

	}

	private class PrintRunnable implements Runnable {

		private LetterPrinter letterPrinter = null;

		private char letter = ' ';

		/**
		 * @param letterPrinter
		 * @param letter
		 */
		public PrintRunnable(LetterPrinter letterPrinter, char letter) {
			super();
			this.letterPrinter = letterPrinter;
			this.letter = letter;
		}

		public void run() {
			for (int i = 0; i < 10; i++) {
				synchronized (letterPrinter) {
					while (letter != letterPrinter.getLetter()) {
						try {
							letterPrinter.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}

					letterPrinter.print();
					letterPrinter.nextLetter();
					letterPrinter.notifyAll();

				}
			}

		}

	}

}</span>


JDK 1.5 引入J.U.C包之后，也给我们提供了更多实现多线程程序的选择: Condition, 原子类AtomicInteger以及Semaphore等。


使用Lock 和 Condition
Java代码 复制代码
  1. package my.thread.test;   
  2.   
  3. import java.util.concurrent.ExecutorService;   
  4. import java.util.concurrent.Executors;   
  5. import java.util.concurrent.locks.Condition;   
  6. import java.util.concurrent.locks.Lock;   
  7. import java.util.concurrent.locks.ReentrantLock;   
  8. import java.util.logging.Logger;   
  9.   
  10. /**  
  11.  * 题目：有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…  
  12.  *   
  13.  * 本程序采用Lock和Condition来实现。  
  14.  *   
  15.  * @author Eric  
  16.  *   
  17.  */  
  18. public class ConditionExample {   
  19.   
  20.     private Lock lock = new ReentrantLock();   
  21.   
  22.     private Condition conditionA = lock.newCondition();   
  23.     private Condition conditionB = lock.newCondition();   
  24.     private Condition conditionC = lock.newCondition();   
  25.   
  26.     /** 当前线程的名字 */  
  27.     private char currentThreadName = 'A';   
  28.   
  29.     private static final Logger logger = Logger   
  30.             .getLogger("my.thread.test.OrderPrintTest");   
  31.   
  32.     public static void main(String[] args) {   
  33.   
  34.         ConditionExample ce = new ConditionExample();   
  35.   
  36.         ExecutorService service = Executors.newFixedThreadPool(3);   
  37.         service.execute(ce.new ThreadA());   
  38.         service.execute(ce.new ThreadB());   
  39.         service.execute(ce.new ThreadC());   
  40.   
  41.         service.shutdown();   
  42.     }   
  43.   
  44.     private class ThreadA implements Runnable {   
  45.         public void run() {   
  46.   
  47.             for (int i = 0; i < 10; i++) {   
  48.                 lock.lock();   
  49.                 try {   
  50.                     while (currentThreadName != 'A') {   
  51.                         try {   
  52.                             /*  
  53.                              * 如果当前线程名字不是A，那么ThreadA就处理等待状态  
  54.                              */  
  55.                             conditionA.await();   
  56.                         } catch (InterruptedException e) {   
  57.                             logger.severe(e.getLocalizedMessage());   
  58.                         }   
  59.                     }   
  60.   
  61.                     /*  
  62.                      * 打印出第几遍以及A信息  
  63.                      */  
  64.                     System.out.println(String.format("第%d遍", i + 1));   
  65.                     System.out.println("A");   
  66.   
  67.                     /*  
  68.                      * 将当前线程名置为B， 然后通知ThreadB执行  
  69.                      */  
  70.                     currentThreadName = 'B';   
  71.                     conditionB.signal();   
  72.   
  73.                 } finally {   
  74.                     lock.unlock();   
  75.                 }   
  76.             }   
  77.         }   
  78.   
  79.     }   
  80.   
  81.     private class ThreadB implements Runnable {   
  82.         public void run() {   
  83.             for (int i = 0; i < 10; i++) {   
  84.                 lock.lock();   
  85.                 try {   
  86.                     while (currentThreadName != 'B') {   
  87.                         try {   
  88.                             /*  
  89.                              * 如果当前线程名字不是B，那么ThreadB就处理等待状态  
  90.                              */  
  91.                             conditionB.await();   
  92.                         } catch (InterruptedException e) {   
  93.                             logger.severe(e.getLocalizedMessage());   
  94.                         }   
  95.                     }   
  96.   
  97.                     /*  
  98.                      * 打印信息B  
  99.                      */  
  100.                     System.out.println("B");   
  101.   
  102.                     /*  
  103.                      * 将当前线程值置为C 并通过ThreadC来执行  
  104.                      */  
  105.                     currentThreadName = 'C';   
  106.                     conditionC.signal();   
  107.   
  108.                 } finally {   
  109.                     lock.unlock();   
  110.                 }   
  111.             }   
  112.   
  113.         }   
  114.   
  115.     }   
  116.   
  117.     private class ThreadC implements Runnable {   
  118.   
  119.         public void run() {   
  120.             for (int i = 0; i < 10; i++) {   
  121.                 lock.lock();   
  122.                 try {   
  123.                     while (currentThreadName != 'C') {   
  124.                         try {   
  125.                             /*  
  126.                              * 如果当前线程名字不是C，那么ThreadC就处理等待状态  
  127.                              */  
  128.                             conditionC.await();   
  129.                         } catch (InterruptedException e) {   
  130.                             logger.severe(e.getLocalizedMessage());   
  131.                         }   
  132.                     }   
  133.   
  134.                     /*  
  135.                      * 打印信息C  
  136.                      */  
  137.                     System.out.println("C");   
  138.                     System.out.println();   
  139.   
  140.                     /*  
  141.                      * 将当前线程值置为A 并通过ThreadA来执行  
  142.                      */  
  143.                     currentThreadName = 'A';   
  144.                     conditionA.signal();   
  145.   
  146.                 } finally {   
  147.                     lock.unlock();   
  148.                 }   
  149.   
  150.             }   
  151.         }   
  152.     }   
  153. }  
<span style="font-family:KaiTi_GB2312;font-size:18px;">package my.thread.test;

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

/**
 * 题目：有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…
 * 
 * 本程序采用Lock和Condition来实现。
 * 
 * @author Eric
 * 
 */
public class ConditionExample {

	private Lock lock = new ReentrantLock();

	private Condition conditionA = lock.newCondition();
	private Condition conditionB = lock.newCondition();
	private Condition conditionC = lock.newCondition();

	/** 当前线程的名字 */
	private char currentThreadName = 'A';

	private static final Logger logger = Logger
			.getLogger("my.thread.test.OrderPrintTest");

	public static void main(String[] args) {

		ConditionExample ce = new ConditionExample();

		ExecutorService service = Executors.newFixedThreadPool(3);
		service.execute(ce.new ThreadA());
		service.execute(ce.new ThreadB());
		service.execute(ce.new ThreadC());

		service.shutdown();
	}

	private class ThreadA implements Runnable {
		public void run() {

			for (int i = 0; i < 10; i++) {
				lock.lock();
				try {
					while (currentThreadName != 'A') {
						try {
							/*
							 * 如果当前线程名字不是A，那么ThreadA就处理等待状态
							 */
							conditionA.await();
						} catch (InterruptedException e) {
							logger.severe(e.getLocalizedMessage());
						}
					}

					/*
					 * 打印出第几遍以及A信息
					 */
					System.out.println(String.format("第%d遍", i + 1));
					System.out.println("A");

					/*
					 * 将当前线程名置为B， 然后通知ThreadB执行
					 */
					currentThreadName = 'B';
					conditionB.signal();

				} finally {
					lock.unlock();
				}
			}
		}

	}

	private class ThreadB implements Runnable {
		public void run() {
			for (int i = 0; i < 10; i++) {
				lock.lock();
				try {
					while (currentThreadName != 'B') {
						try {
							/*
							 * 如果当前线程名字不是B，那么ThreadB就处理等待状态
							 */
							conditionB.await();
						} catch (InterruptedException e) {
							logger.severe(e.getLocalizedMessage());
						}
					}

					/*
					 * 打印信息B
					 */
					System.out.println("B");

					/*
					 * 将当前线程值置为C 并通过ThreadC来执行
					 */
					currentThreadName = 'C';
					conditionC.signal();

				} finally {
					lock.unlock();
				}
			}

		}

	}

	private class ThreadC implements Runnable {

		public void run() {
			for (int i = 0; i < 10; i++) {
				lock.lock();
				try {
					while (currentThreadName != 'C') {
						try {
							/*
							 * 如果当前线程名字不是C，那么ThreadC就处理等待状态
							 */
							conditionC.await();
						} catch (InterruptedException e) {
							logger.severe(e.getLocalizedMessage());
						}
					}

					/*
					 * 打印信息C
					 */
					System.out.println("C");
					System.out.println();

					/*
					 * 将当前线程值置为A 并通过ThreadA来执行
					 */
					currentThreadName = 'A';
					conditionA.signal();

				} finally {
					lock.unlock();
				}

			}
		}
	}
}</span>



使用Semaphore
Java代码 复制代码
  1. package my.thread.test;   
  2.   
  3. import java.util.concurrent.ExecutorService;   
  4. import java.util.concurrent.Executors;   
  5. import java.util.concurrent.Semaphore;   
  6.   
  7. public class SemaphoresExample {   
  8.   
  9.     private Semaphore semaphoresA = new Semaphore(1);   
  10.     private Semaphore semaphoresB = new Semaphore(0);   
  11.     private Semaphore semaphoresC = new Semaphore(0);   
  12.   
  13.     public static void main(String[] args) {   
  14.         SemaphoresExample example = new SemaphoresExample();   
  15.         ExecutorService service = Executors.newFixedThreadPool(3);   
  16.   
  17.         service.execute(example.new RunnableA());   
  18.         service.execute(example.new RunnableB());   
  19.         service.execute(example.new RunnableC());   
  20.   
  21.         service.shutdown();   
  22.     }   
  23.   
  24.     private class RunnableA implements Runnable {   
  25.   
  26.         public void run() {   
  27.   
  28.             for (int i = 0; i < 10; i++) {   
  29.                 try {   
  30.                     semaphoresA.acquire();   
  31.                 } catch (InterruptedException e) {   
  32.                     // TODO Auto-generated catch block   
  33.                     e.printStackTrace();   
  34.                 }   
  35.                 System.out.println(String.format("第%d遍", i + 1));   
  36.                 System.out.println("A");   
  37.                 semaphoresB.release();   
  38.   
  39.             }   
  40.         }   
  41.     }   
  42.   
  43.     private class RunnableB implements Runnable {   
  44.   
  45.         public void run() {   
  46.   
  47.             for (int i = 0; i < 10; i++) {   
  48.                 try {   
  49.                     semaphoresB.acquire();   
  50.                 } catch (InterruptedException e) {   
  51.                     // TODO Auto-generated catch block   
  52.                     e.printStackTrace();   
  53.                 }   
  54.                 System.out.println("B");   
  55.                 semaphoresC.release();   
  56.             }   
  57.   
  58.         }   
  59.     }   
  60.   
  61.     private class RunnableC implements Runnable {   
  62.   
  63.         public void run() {   
  64.   
  65.             for (int i = 0; i < 10; i++) {   
  66.                 try {   
  67.                     semaphoresC.acquire();   
  68.                 } catch (InterruptedException e) {   
  69.                     // TODO Auto-generated catch block   
  70.                     e.printStackTrace();   
  71.                 }   
  72.                 System.out.println("C");   
  73.                 System.out.println();   
  74.   
  75.                 semaphoresA.release();   
  76.             }   
  77.         }   
  78.     }   
  79. }  
<span style="font-family:KaiTi_GB2312;font-size:18px;">package my.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoresExample {

	private Semaphore semaphoresA = new Semaphore(1);
	private Semaphore semaphoresB = new Semaphore(0);
	private Semaphore semaphoresC = new Semaphore(0);

	public static void main(String[] args) {
		SemaphoresExample example = new SemaphoresExample();
		ExecutorService service = Executors.newFixedThreadPool(3);

		service.execute(example.new RunnableA());
		service.execute(example.new RunnableB());
		service.execute(example.new RunnableC());

		service.shutdown();
	}

	private class RunnableA implements Runnable {

		public void run() {

			for (int i = 0; i < 10; i++) {
				try {
					semaphoresA.acquire();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println(String.format("第%d遍", i + 1));
				System.out.println("A");
				semaphoresB.release();

			}
		}
	}

	private class RunnableB implements Runnable {

		public void run() {

			for (int i = 0; i < 10; i++) {
				try {
					semaphoresB.acquire();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("B");
				semaphoresC.release();
			}

		}
	}

	private class RunnableC implements Runnable {

		public void run() {

			for (int i = 0; i < 10; i++) {
				try {
					semaphoresC.acquire();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				System.out.println("C");
				System.out.println();

				semaphoresA.release();
			}
		}
	}
}</span>



使用AtomicInteger
Java代码 复制代码
  1. package my.thread.test;   
  2.   
  3. import java.util.concurrent.ExecutorService;   
  4. import java.util.concurrent.Executors;   
  5. import java.util.concurrent.atomic.AtomicInteger;   
  6.   
  7. public class AtomicIntegerExample {   
  8.   
  9.     private AtomicInteger sycValue = new AtomicInteger(0);   
  10.   
  11.     private static final int MAX_SYC_VALUE = 3 * 10;   
  12.   
  13.     public static void main(String[] args) {   
  14.         AtomicIntegerExample example = new AtomicIntegerExample();   
  15.         ExecutorService service = Executors.newFixedThreadPool(3);   
  16.   
  17.         service.execute(example.new RunnableA());   
  18.         service.execute(example.new RunnableB());   
  19.         service.execute(example.new RunnableC());   
  20.   
  21.         service.shutdown();   
  22.     }   
  23.   
  24.     private class RunnableA implements Runnable {   
  25.   
  26.         public void run() {   
  27.   
  28.             while (sycValue.get() < MAX_SYC_VALUE) {   
  29.                 if (sycValue.get() % 3 == 0) {   
  30.                     System.out.println(String.format("第%d遍",   
  31.                             sycValue.get() / 3 + 1));   
  32.                     System.out.println("A");   
  33.                     sycValue.getAndIncrement();   
  34.                 }   
  35.             }   
  36.   
  37.         }   
  38.     }   
  39.   
  40.     private class RunnableB implements Runnable {   
  41.   
  42.         public void run() {   
  43.   
  44.             while (sycValue.get() < MAX_SYC_VALUE) {   
  45.                 if (sycValue.get() % 3 == 1) {   
  46.                     System.out.println("B");   
  47.                     sycValue.getAndIncrement();   
  48.                 }   
  49.             }   
  50.   
  51.         }   
  52.     }   
  53.   
  54.     private class RunnableC implements Runnable {   
  55.   
  56.         public void run() {   
  57.   
  58.             while (sycValue.get() < MAX_SYC_VALUE) {   
  59.                 if (sycValue.get() % 3 == 2) {   
  60.                     System.out.println("C");   
  61.                     System.out.println();   
  62.                     sycValue.getAndIncrement();   
  63.                 }   
  64.             }   
  65.   
  66.         }   
  67.     }   
  68. }  
技术搬砖工
关注
专栏目录
2024年Unity 面试题 |五萬字 二佰道| Unity面试题大全，面试题总结【全网最全，收藏一篇足够面试】
努力前行，总会成为自己心中的那道光
02-23 12万+
正所谓 金三银四 ，又到了找工作的大好时机了，不知道大家有没有意向找一份更好的工作呢~ 之前写了很多Unity的学习和实例文章，但是面试题部分还没有一个系统的整理。 那本篇文章就来整理一下Unity中一些常见的面试题，说不准就会面试的时候就会遇到！ 本篇文章会将Unity所有方面的面试资料都融会贯通，绝对是2022年Unity面试领域最实用的文章啦！
js面试题----2
MingL520的博客
05-27 232
Object是JavaScript中所有对象的父对象ObjectArrayBooleanNumber和StringFunctionArgumentsMathDateRegExpError闭包就是能够读取其他函数内部变量的函数闭包是指有权访问另一个函数作用域中变量的函数，创建闭包的最常见的方式就是在一个函数内创建另一个函数，通过另一个函数访问这个函数的局部变量,利用闭包可以突破作用链域函数内再嵌套函数内部函数可以引用外层的参数和变量参数和变量不会被垃圾回收机制回收说说你对闭包的理解。
ABC循环打印
Heorin X的博客
09-08 404
多线程循环打印问题 package jstudy.thread; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author Heroin X * @date 2020/9/7 19:56 */ public class ThreadTest1 { pr
Java多线程：用三个线程控制循环输出10次ABC
HZC的专栏
09-09 9371
题目：有A,B,C三个线程, A线程输出A, B线程输出B, C线程输出C，要求, 同时启动三个线程, 按顺序输出ABC, 循环10次。 解题思路：要按顺序输出ABC, 循环10次，就要控制三个线程同步工作，也就是说要让三个线程轮流输出，直到10个ABC全部输出则结束线程。这里用一个Lock对象来控制三个线程的同步。用一个int型变量state标识由那个线程输出。 package co
【多线程】如何实现三个线程循环打印ABC
最新发布
m0_61814277的博客
08-12 1873
本期内容主要介绍如何三个线程循环按顺序打印ABC，探讨细节，并介绍竞态条件的相关知识。
多线程交替打印ABC的多种实现方法
热门推荐
想作会飞的鱼的博客
08-17 6万+
一、题目描述建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。二、Synchronized同步法1、基本思路使用同步块和wait、notify的方法控制三个线程的执行次序。具体方法如下：从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->Thre
三个线程轮流打印ABC
Infor_learning的博客
07-14 7181
1、多线程if和where的区别： 就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。 2、 一.概述wait()方法可以使线程进入等待状态，而notify()可以使等待的状态唤醒 wait，notify和notifyAll方法是Object类的成员函数，所以Java的任何一个.
三个线程循环打印ABC各10次
stackCSDN的博客
04-10 327
package com.hangzhou.springcloud.service.impl; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class ThreadPrintTest { public static void ma...
python多线程实现for循环_python 多线程实现循环打印 abc
weixin_39664994的博客
12-20 1093
python 多线程实现循环打印 abc好久没写过python了， 想自己实践一下把非阻塞版import threadingimport timedef print_a():global valueglobal lockglobal stop_flagwhile stop_flag:while True:if value == 0 or value == 3:breaklock.acquire()...
unity面试题整理----50道常见
m0_60707660的博客
04-30 549
是指在显示器上为了显示出图像而经过的一系列必要操作。渲染管道中的很多步骤，都要将几何物体从一个坐标系中变换到另一个坐标系中去。主要步骤有：本地坐标->视图坐标->背面裁剪->光照->裁剪->投影->视图变换->光栅化。
C++后台开发面试题总结(涉及C++基础、多线程多进程、网络编程等)
Linux高级开发的博客
03-11 6987
C++后台开发面试题总结(涉及C++基础知识、多线程多进程、TCP/IP网络编程、Linux操作、数据结构与算法) 因巩固知识体系，面试，梳理以往看到过的知识点，故总结如下相关题目，题目答案请自行google baidu，这里只提供题目。 一、C++基础知识面试题总结 1、多态的实现 2、说说C/C++的区别 3、const关键字 4、说说malloc/free 和 new/delete区别 5、指针和引用的区别 6、C++中堆和栈的区别 7、关键字static 8、在C++程序中调用被
三个线程循环打印ABC10次的几种解决方法
yamaxifeng_132的专栏
04-03 1864
题目:有三个线程分别打印A、B、C，请用多线程编程实现，在屏幕打印10次ABC 整体思路：该问题为三个线程的同步唤醒机制即ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。 public class MyThreadPrinter2 implements Runnable { private String name; p...
Juc_无juc情况
959
03-02 496
Synchronized和Lock的区别 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; class Ticket{ private int number = 30; private Lock lock = new ReentrantLock(); public void sale(){ lock.lock(); tr
有三个线程ＩＤ分别是ＡＢＣ，用多线程编程在屏幕上循环打印ABCABC....十次
weixin_34256074的博客
10-13 98
package thread; /** * 有三个线程ＩＤ分别是ＡＢＣ，用多线程编程在屏幕上循环打印ABCABC....十次 * @author luoxiaoyi */ public class TestThread { public static void main(String[] args) { new Thread(new O...
java.只创建三个线程循环打印十次 ABC
qq_45239139的博客
12-22 336
题目： 最多只允许创建三个线程来完成循环打印十次 ABC 的操作。 完成效果如下所示： ABC ABC ABC … 十次 源码： package lesson2; public class SequencePrint { // 数组是 java 对象，是放在堆里面的 // 定义需要打印的顺序 private static String[] INFOS = {"A", "...
java同步三线程打印abc_三线程打印ABC，循环十次的N种实现方式
weixin_33888685的博客
02-25 405
编写一个程序，开启 3 个线程 A,B,C，这三个线程的输出分别为 A、B、C，每个线程将自己的 输出在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。如：ABCABCABC....方法1，轮询AtomicInteger缺点是轮询白耗CPU，性能很差package com.mocyx.javacc.printer;import org.springframework.stereotype.Co...
3个线程循环打印ABC
carey_OoO的博客
06-10 1421
java 多线程 同步
Java 3个线程依次打印ABC，并且循环10次
kk的专栏
08-07 968
public class ABCThread {public static void main(String[] args) {new Thread(new Printer(" A", 0)).start();new Thread(new Printer(" B", 1)).start();new Thread(new Printer("C", 2)).start();}}class Printe
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值