`
jsczxy2
  • 浏览: 1277614 次
  • 性别: Icon_minigender_1
  • 来自: 常州
文章分类
社区版块
存档分类
最新评论

java多线程问题集锦(二)

阅读更多

用多线程的方式实现对一个数随机自增N次,随机自减M次,最后打印出这个数字(不能用原子操作类AtomicInteger)。

 

 

package com.test;

public class TestThreadTwo {

	public static void main(String[] args) {
		int num = 0;
		int total = 0;
		int increase_count = 4000;
		int decrease_count = 3000;
		int sum_count = increase_count + decrease_count;
		OperatorTwo o = new OperatorTwo(num, total);
		//打印监控线程启动
		new PrintThread(o, sum_count).start();
		//所有加减线程启动
		for(int i =0;i<increase_count;i++){
			new IncreaseThreadTwo(o).start();
		}
		for(int i =0;i<decrease_count;i++){
			new DecreaseThreadTwo(o).start();
		}
	}
}

class OperatorTwo {
	private int num;
	private int total;

	public OperatorTwo(int num, int total) {
		this.num = num;
	}

	public int getNum() {
		return num;
	}

	public int getTotal() {
		return total;
	}

	public synchronized void increase() {
		num++;
	}

	public synchronized void decrease() {
		num--;
	}

	public synchronized void increaseTotal() {
		total++;
	}
}

class IncreaseThreadTwo extends Thread {
	private OperatorTwo o;

	public IncreaseThreadTwo(OperatorTwo o) {
		this.o = o;
	}

	@Override
	public void run() {
		try {
			Thread.sleep((long) (Math.random() * 100));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		o.increase();
		o.increaseTotal();
	}
}

class DecreaseThreadTwo extends Thread {
	private OperatorTwo o;

	public DecreaseThreadTwo(OperatorTwo o) {
		this.o = o;
	}

	@Override
	public void run() {
		try {
			Thread.sleep((long) (Math.random() * 100));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		o.decrease();
		o.increaseTotal();
	}
}

class PrintThread extends Thread{
	private OperatorTwo o;
	private int sum_count;
	
	public PrintThread(OperatorTwo o,int sum_count) {
		this.o = o;
		this.sum_count=sum_count;
	}
	@Override
	public void run() {
		while(true){
			if(o.getTotal()==sum_count){
				System.out.println("最终结果:"+o.getNum());
				break;
			}
		}
	}
}
 

 

package com.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;

public class TestThreadOne {

	public static void main(String[] args) {
		int num = 0;
		int increase_count = 40000;
		int decrease_count = 30000;
		Operator o = new Operator(num);
		List<Thread> threads = new ArrayList<Thread>(); 
		for (int i = 0; i < increase_count; i++) {
			Thread t = new IncreaseThreadO(o);
			threads.add(t);
			t.start();
		}
		for (int i = 0; i < decrease_count; i++) {
			Thread t = new DecreaseThreadO(o);
			threads.add(t);
			t.start();
		}
		/*
		List<Thread> ts = new ArrayList<Thread>();
		while(threads.size()>0){
			for(Thread t : threads){
				if(t.isAlive()){
					ts.add(t);
				}
			}
			threads.clear();
			threads.addAll(ts);
			ts.clear();
		}*/
		int sum = increase_count + decrease_count;
		int count = 0;
		ListIterator<Thread> it = null;
		while(count<sum){
			it = threads.listIterator();
			while(it.hasNext()){
				Thread t =it.next();
				if(t!=null&&!t.isAlive()){
					count++;
					it.set(null);
				}
			}
		}
		System.out.println("最终结果"+o.getNum());
	}
}

class Operator {
	private int num;

	public Operator(int num) {
		this.num = num;
	}

	public int getNum() {
		return num;
	}

	public synchronized void increase() {
		num++;
	}

	public synchronized void decrease() {
		num--;
	}
}

class IncreaseThreadO extends Thread {
	private Operator o;

	public IncreaseThreadO(Operator o) {
		this.o = o;
	}

	@Override
	public void run() {
		try {
			Thread.sleep((long)(Math.random()*100));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		o.increase();
	}
}

class DecreaseThreadO extends Thread {
	private Operator o;

	public DecreaseThreadO(Operator o) {
		this.o = o;
	}

	@Override
	public void run() {
		try {
			Thread.sleep((long)(Math.random()*100));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		o.decrease();
	}
}
 

 

package com.test;

import java.util.ArrayList;
import java.util.List;

public class TestThreadOne {

	public static void main(String[] args) {
		int num = 0;
		int increase_count = 4000;
		int decrease_count = 3000;
		Operator o = new Operator(num);
		List<Thread> threads = new ArrayList<Thread>(); 
		for (int i = 0; i < increase_count; i++) {
			Thread t = new IncreaseThreadO(o);
			threads.add(t);
			t.start();
		}
		for (int i = 0; i < decrease_count; i++) {
			Thread t = new DecreaseThreadO(o);
			threads.add(t);
			t.start();
		}
		List<Thread> ts = new ArrayList<Thread>();
		while(threads.size()>0){
			for(Thread t : threads){
				if(t.isAlive()){
					ts.add(t);
				}
			}
			threads.clear();
			threads.addAll(ts);
			ts.clear();
		}
		System.out.println("最终结果"+o.getNum());
	}
}

class Operator {
	private int num;

	public Operator(int num) {
		this.num = num;
	}

	public int getNum() {
		return num;
	}

	public synchronized void increase() {
		num++;
	}

	public synchronized void decrease() {
		num--;
	}
}

class IncreaseThreadO extends Thread {
	private Operator o;

	public IncreaseThreadO(Operator o) {
		this.o = o;
	}

	@Override
	public void run() {
		try {
			Thread.sleep((long)(Math.random()*100));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		o.increase();
	}
}

class DecreaseThreadO extends Thread {
	private Operator o;

	public DecreaseThreadO(Operator o) {
		this.o = o;
	}

	@Override
	public void run() {
		try {
			Thread.sleep((long)(Math.random()*100));
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		o.decrease();
	}
}
分享到:
评论

相关推荐

    15个多线程问题集锦

    ### 15个多线程问题集锦:Java多线程的核心使用问题及注意事项 #### 1. 多线程执行顺序控制 - **问题描述**:假设存在三个线程T1、T2、T3,如何确保T2在线程T1执行完毕后开始执行,而T3又在线程T2执行完毕后开始...

    Java 多线程编程面试集锦20道问题解答Java多线程编程高难度面试题及解析

    以下是一些关于Java多线程编程的知识点: 1. **线程安全**:在多线程环境中,线程安全意味着多个线程访问共享数据时不会引发数据不一致或异常。实现线程安全的方法包括使用`synchronized`关键字、Lock接口(如...

    Java案例开发集锦(第二版)源代码

    《Java案例开发集锦(第二版)》是Java学习者的一份宝贵资源,它由袁然、郑自国等多位专业作者共同编写,旨在通过实际的项目案例来深入讲解Java编程技术。这份源代码集合包含了书中所有示例的实现,为初学者提供了直观...

    Java常见问题集锦 _Java常见问题集锦_

    6. **多线程**: - **Thread类与Runnable接口**:创建线程有两种方式,直接继承Thread类或实现Runnable接口。后者更适合多个线程共享同一个资源。 - **同步机制**:synchronized关键字用于控制并发访问,避免数据...

    Java经典项目集锦

    5. **多线程编程**:Java提供了丰富的多线程支持,经典项目会涵盖线程同步、线程池、守护线程等概念。比如,实现一个下载器,需要用到多线程并发下载,这就涉及到线程间的协作和控制。 6. **异常处理**:在实际项目...

    JAVA案例开发集锦pdf

    6. **多线程**:Java提供了强大的多线程支持,书中会有创建和管理线程、线程同步、锁机制等相关实例,帮助读者理解和运用并发编程。 7. **网络编程**:Java的Socket编程接口使得创建网络应用程序成为可能,书中的...

    Java 高并发多线程编程系列案例代码

    Java 高并发多线程编程系列案例代码 & 教程 & 面试题集锦! !! 包括但不限于线程安全性, atomic包下相关类、CAS原理、Unsafe类、synchronized关键字等的使用及注意事项,

    java面试笔试题集锦

    4. **多线程**:Java提供了丰富的多线程支持,如Thread类、Runnable接口、同步机制(synchronized关键字、Lock锁、信号量等)、线程池(ExecutorService)等。 5. **IO流与NIO**:输入/输出流的理解,以及...

    java面试问题集锦

    ### Java面试问题集锦 #### 一、运行程序之前: ##### Path与classpath图解 - **Path**:指的是操作系统环境变量中的PATH,它定义了系统查找可执行文件的路径列表。当用户在命令行中输入一个命令时,系统会在PATH...

    Java编程精选集锦

    6. **多线程**:Java内置了对多线程的支持,通过Thread类和Runnable接口可以创建并管理多个执行线程,实现并发执行任务。 7. **网络编程**:Java的Socket编程允许创建客户端和服务器应用,进行TCP/IP通信。...

    java 常见问题集锦

    7. **多线程**:Java内置对多线程的支持,通过`Thread`类或实现`Runnable`接口创建线程。理解线程同步、互斥、死锁等概念,能有效地编写并发程序。 8. **泛型**:泛型引入了类型安全,允许在编译时检查类型。理解并...

    java面试题集锦 java基础、集合、多线程等

    Java 面试题集锦 Java 基础知识点: 1. JDK 和 JRE 的区别: JDK(Java Development Kit)是 Java 开发工具包,提供了 Java 的开发环境和运行环境。JRE(Java Runtime Environment)是 Java 运行环境,为 Java 的...

    JAVA案例开发集锦

    这本书的核心就在于提供了一系列的实际项目案例,这些案例涵盖了JAVA开发的多个方面,包括但不限于基础语法、面向对象编程、异常处理、集合框架、多线程、网络编程、IO流、数据库操作、Swing图形界面设计、JSP与...

    java笔试题经典集锦

    11. **多线程**:线程的创建(Thread类和Runnable接口)、线程同步(synchronized关键字、wait()、notify()、notifyAll()方法)以及线程池的使用。 12. **内存模型**:了解JVM内存结构,包括堆内存、栈内存、方法区...

    Java工程师面试题集锦

    ### Java工程师面试题集锦详解 #### Java基础知识 1. **作用域public, protected, private, 以及不写时的区别** - **public**: 公开的,可以在任何地方被访问,包括同一个类、同一个包内及不同包内的类。 - **...

    Java常见问题集锦 java_faq.rar

    6. **多线程**:线程的创建、同步、通信,以及死锁、活锁的概念和避免策略。 7. **反射机制**:如何在运行时获取类的信息,动态创建对象,调用方法等。 8. **JVM内存管理**:理解堆、栈、方法区,垃圾收集的工作原理...

    JAVA桉例开发集锦

    多线程是Java的一大亮点,书中的实例将指导你如何创建和管理线程,理解同步和互斥的概念,以及如何使用锁机制确保程序的并发安全。 此外,Java还提供了丰富的API,如Swing和JavaFX用于构建桌面应用,Servlet和JSP...

    Java编程代码实例集锦

    6. **多线程**:Java支持多线程编程,通过Thread类或Runnable接口实现,有助于提高程序的并发性能。 7. **反射机制**:Java反射允许在运行时检查类的信息,动态创建对象和调用方法,这对于编写通用性强的代码非常...

    Java编程精选集锦(附源代码)

    6. **多线程**:Java提供了丰富的多线程支持,如Thread类和Runnable接口。理解线程的生命周期,同步机制(如synchronized关键字、wait()、notify()方法)以及并发工具类(如Semaphore、CyclicBarrier、...

Global site tag (gtag.js) - Google Analytics