A. java用多线程实现累加求和
class Thread_test extends Thread
{
int number;
public static int sum;
public Thread_test(int n) //构造函数
{
number=n;
}
public static synchronized void add(int num){ //同步方法
sum += num;
}
public void run()
{
int count=0;
for(int i=0;i<10;i++)
{
count+=number+i;
}
System.out.println("The "+((int)number/10+1)+" time: "+count);
add(count);
}
}
public class Main{
public static void main(String args[]) {
Thread_test test[] = new Thread_test[10];
for (int i = 0; i < 10; i++) {
test[i] = new Thread_test(i*10+1);
test[i].start();
try {
test[i].join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Total is "+Thread_test.sum);
}
}
B. 如何在c盘中查看java线程数
Windows
通过任务管理器查看进程信息
在进程页签中查看Java进程，我是idea启动，因此可以在idea下查看相关进程
此外可以在详细信息页签下Ctrl+f搜索java
通过控制台查看进程信息
进入CMD，键入tasklist，可以查看所有的进程信息，包括进程ID、内存使用情况
查看Java相关的进程，可以添加过滤条件 tasklist | findstr "java" ，需要注意windows中字符串需要使用双引号，要不就不加也是可以的
如果是在IDEA中启动程序，可以借用idea的Terminal终端执行命令
taskkill 杀死进程
杀死进程使用taskkill /pid 指定进程id，如果无法杀死，可以尝试强制杀死taskkill /pid 进程id -t -f
可以看到idea控制台中进程已结束
通过tasklist | findstr 进程id 已经无法查询到该进程，说明进程终止成功
C. java 多线程 求和
帮你帮到底，你凑合着看看吧
package test;
import java.io.*;
class testthread
extends Thread {
int b[] = null;
public testthread(int[] a) {
b = a;
}
public void run() {
int sum = 0;
for (int i = 0; i < b.length; i++) {
sum = sum + b[i];
}
System.out.println(sum);
thread.tnumInc(sum);
}
}
public class thread {
private static int ready = 0;
private static int tnum = 0;
private static int SUM = 0;
static synchronized void tnumInc(int p)
{
ready++;
SUM += p;
if(ready>=tnum){
System.out.println(SUM);
}
}
/**
* @param args
*/
public static void main(String args[]) {
// TODO 自动生成方法存根
try {
System.out.print("输入线程数 p(p>=2)：");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String A = (String) br.readLine();
int p = Integer.parseInt(A);
tnum = p;
System.out.print("输入求和数 n：");
BufferedReader cr = new BufferedReader(new InputStreamReader(System.in));
String B = (String) cr.readLine();
String x[] = B.split(" ");
int[] n = new int[x.length];
for (int i = 0; i < x.length; i++) {
n[i] = new Integer(x[i]).intValue();
}
int c = n.length / p;
int a[][] = new int[p][c]; //定义一个多维数组
int b = 0;
for (int i = 0; i < p; i++) //将n[]中元素赋值给多维数组
for (int j = 0; j < c; j++) {
a[i][j] = n[b];
b++;
}
for (int i = 0; i < p; i++) { //测试多维数组输出
for (int j = 0; j < c; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println();
}
for (int i = 0; i < p; i++) //创建线程
new testthread(a[i]).start();
}
catch (IOException e) {}
}
}
随便写写，没有测试过。你自己调调看吧。
大概思路就是给一个方法合并结果，并对已经完成的thread进行计数
当完成的thread的数量==总数的时候，最后结果就出来了
D. java 如何获得线程池中正在执行的线程数
java中线程池的监控可以检测到正在执行的线程数。
通过线程池提供的参数进回行监控。线程池里有一答些属性在监控线程池的时候可以使用
taskCount：线程池需要执行的任务数量。
completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCount。
largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。如等于线程池的最大大小，则表示线程池曾经满了。
getPoolSize:线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不+ getActiveCount：获取活动的线程数。
通过扩展线程池进行监控。通过继承线程池并重写线程池的beforeExecute，afterExecute和terminated方法，我们可以在任务执行前，执行后和线程池关闭前干一些事情。如监控任务的平均执行时间，最大执行时间和最小执行时间等。这几个方法在线程池里是空方法。如：
protected void beforeExecute(Thread t, Runnable r) { }
E. JAVA多线程累加
ExecutorServicethreadPool2=Executors.newFixedThreadPool(10);
ExecutorCompletionService<Integer>executorCompletionService=newExecutorCompletionService<Integer>(
threadPool2);
for(inti=0;i<10;i++){
executorCompletionService.submit(newCallable<Integer>(){
@
publicIntegercall()throwsException{
intsum=0;
for(intj=0;j<10;j++){
sum+=newRandom().nextInt(1000);
}
System.out.println("num:"+sum);
returnsum;
}
});
}
intsum=0;
for(inti=0;i<10;i++){
try{
intnum=executorCompletionService.take().get();
sum+=num;
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(ExecutionExceptione){
e.printStackTrace();
}
}
System.out.println("sum:"+sum);
F. java多线程，要求三个线程，一个从0开始计数，一个存放计数，一个输出
将计数、存放、输出三个方法中的目标变量进行同步。就可以了
也就是说，当3个线程同时使用数据时，让它们排个队，一个一个来。
G. JAVA采用实现Runnable接口的多线程技术，用50个线程，生成10000个[1-1000]间的随机整数。
public class RandomNumber implements Runnable {
private final byte[] lock; // 同步对象锁
private Random random; // 用于生成随机数
private int sum; // 用于计算产生的随机数总数
public RandomNumber() {
lock = new byte[1];
random = new Random();
}
@Override
public void run() {
while (true) {
int rd = random.nextInt(1001); // 产生0 - 10000的随机数
if (rd == 0) {
continue;
} else {
if (sum >= 10000) {
return;
}
try {
Thread.sleep(1); // 为了效果更明显，当前线程睡1毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (lock) {
// 获取到对象锁之后，需要判断sum的大小，因为此时sum可能已经为10000了
if (sum < 10000) {
sum++;
System.out.println(Thread.currentThread().getName()
+ " - 第" + sum + "个随机数：" + rd);
}
}
}
}
}
// main测试函数
public static void main(String[] args) throws Exception {
RandomNumber rn = new RandomNumber();
// 循环产生50个线程
for (int i = 0; i < 50; i++) {
new Thread(rn).start();
}
}
}
有问题再追问，一起学习探讨
H. 鍦╦ava涓鎬庢牱缁熻′竴涓绾跨▼鎵ц岀殑娆℃暟鍜屼笉鑳芥墽琛岀殑娆℃暟
鎬濊矾锛
鍒涘缓绾跨▼缁ф壙绾跨▼绫绘垨鑰呭疄鐜扮嚎绋嬫帴鍙
閲嶅啓run鏂规硶
鍦╮un鏂规硶閲岄潰鍐檉or寰鐜锛
寰鐜璇鍙ュ潡涓鎵撳嵃绾跨▼绫荤殑闈欐佹柟娉.currentthread().getname(锛
+寰鐜鐨勮嚜澧炲笺
锛屼富绾跨▼鍒涘缓鑷瀹氫箟瀵硅薄瀹炰緥銆
璋冪敤start锛堬級鏂规硶ok銆併