写十个线程,第一个线程求1到10的和,第二个11到20的和，第三个求21到30的和...第10个求91到100的和,求十个线程的和
new是个Thread，每个Thread传入起始数字
既然是整数，最后就累加到原子锁吧
其实你也可以socket同步的
当然同步的关键字也值得使用
new十个线程，run()用for循环写算法
把总和做成成员变量，给每一个线程传前一个的结婚，最后获取总和
我觉得是否可以这样，你创建10个线程，在线程函数中增加一个flag参数，另外，创建一个全局的数组，10个元素，分别存放10个线程自己的值，
在运行这些线程的时候，传入falg参数，比如：
static a[10] int;
flag int;
sum int=0;
object[10] HANDLE;
for(flag = 1 ; flag <= 10; flag++)
{
object[flag]= CreateThread(你的线程函数，flag);
}
...
WaitForMultileObject(10,object,...); --等待线程返回
for(flag = 1 ; flag <= 10; flag++)
{
sum =sum +object[flag];
}
然后线程函数里：
a[flag]=10+11+12...
貌似是典型的线程分发问题，可以利用CyclicBarrier将分发后的任务汇总，将所有的线程去执行，执行结果后调用显示最后的结果线程。下面写了一段代码可以参考一下。
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
@author zhaohb
*/
public class CounterThread extends Thread{
private int start;
private int end;
private CyclicBarrier barrier ;
public CounterThread(int id,int start, int end,CyclicBarrier barrier) {
this.start = start;
this.end = end;
this.barrier = barrier;
setName("Thread-"+id+" ");
}
@Override
public void run() {
int count = 0;
for(int i=start;i<end+1;i++){
count += i;
}
Counter.totalCount(count);
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
@author zhaohb
*/
public class CounterTest {
public static void main(String[] args) {
//CyclicBarrier指定了当10个线程运行结束时候，可以进行最后结果展示了
CyclicBarrier barrier = new CyclicBarrier(10,new TotalTask(new Counter()));
ExecutorService executorService = Executors.newCachedThreadPool();
for(int i=0;i<10;i++){
int start = i*10+1;
int end = start + 9;
CounterThread counterThread = new CounterThread(i,start, end,barrier);
executorService.execute(counterThread);
}
executorService.shutdown();
}
}
/**
@author zhaohb
*
*/
class Counter {
private static int count =0;
public synchronized static int totalCount(int perCount){
count += perCount;
return count;
}
public int totalResult(){
return count;
}
}
/**
@author zhb
*
*/
class TotalTask implements Runnable{
private Counter counter ;
public TotalTask(Counter counter){
this.counter = counter;
}
@Override
public void run() {
System.out.println("所有线程运行完毕，总结果为：");
int total = counter.totalResult();
System.out.println(total);
}
}
Windows 线程 可以传递参数
就用一个 结构指针就可以了
可以建立结构数组，提供一个ID
表示如何处理数据，
必要时可以传递数据本身，
计算结果也存储在这个 结构中
创建线程时候，每个线程传入数组中的一个元素地址
各个线程结束运行后，对所有结果求和
//分配线程的时候给每个线程肯定分配个开始结束标志(比方每个线程算出个最终值了即ok）。
//另一线程（或拿之前分工的其中之一线程）用于等待周期性判断，几个结束标志都符合了，做相加，任务结束
//作者:shiyun888888
//以下是一个简单WPF程序后台，点击按钮后即可计算，最后弹出结果, 已去除引用
namespace HelloWPF
{
///
/// Window1.xaml 的交互逻辑
///
public partial class Window1 : Window
{
public Window1()
{
InitializeComponent();
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
//主程序
Aha[] aha = new Aha[10];
for (int i = 0; i < 10; i++)
{
aha[i] = new Aha(i * 10, (i + 1) * 10);
ThreadStart ts = new ThreadStart(aha[i].addRange);
Thread t = new Thread(ts);
t.Start();
}
ListenAddOver lao = new ListenAddOver(aha);
while (true)
{
lao.CanOver();
if (lao.Over == 1)
break;
Thread.Sleep(100);
}
MessageBox.Show(lao.LastAns+"");
}
}
class ListenAddOver
{
Aha[] ahas;
int lastAns;
int over; //1: 结束，否则继续
public int LastAns
{
get{return this.lastAns;}
set{this.lastAns=value;}
}
public int Over
{
get { return this.over; }
set { this.over = value; }
}
public ListenAddOver(Aha [] ahas)
{
this.ahas = ahas;
}
public void CanOver()
{
if (ahas == null)
{
over = 1;
}
else
{
this.Over = 1;
this.lastAns = 0;
for (int i = 0; i < ahas.Length; i++)
{
if (ahas[i].Status == 0)
{
this.Over = 0;
this.lastAns = 0;
break;
}
this.lastAns += ahas[i].Ans;
}
}
}
}
class Aha
{
int a;
int b;
int status;//0:开始 1:结束
int ans;
public int Status
{
get { return this.status;}
set {this.status=value;}
}
public int Ans
{
get { return this.ans; }
set { this.ans = value; }
}
public Aha(int pa, int pb)
{
this.a = pa;
this.b = pb;
this.Status = 0;
}
public void addRange()
{
int temp = 0;
for (int i = a; i <= b; i++)
{
temp = temp + i;
}
ans= temp;
this.Status = 1;
}
}
}
是作业吗？^^
写一个线程处理类，有线程，有处理方法，接收起始数字为参数，然后在实例化10个类
new是个Thread，每个Thread传入起始数字 。利用Handler接收所传入的数值并求和。
写一个线程处理类，有线程，有处理方法，接收起始数字为参数，处理完成后通过委托返回值，
然后在调用类,实例化10个类， 给每个线程处理类绑定同一个事件处理方法，在这个事件处理方法里面实现这10个线程的总和。
public class 线程处理类
{
线程
处理完成事件
处理结果/初始值
处理函数
}
上次代码记不得，代码太多，怎么办？怎么查找代码？？？？？？？？？上次代码记不得，代码太多，怎么办？怎么查找代码？？？？？？？？？上次代码记不得，代码太多，怎么办？怎么查找代码？？？？？？？？？上次代码记不得，代码太多，怎么办？怎么查找代码？？？？？？？？？上次代码记不得，代码太多，怎么办？怎么查找代码？？？？？？？？？
在楼主想想想别人写好的代码时，我给楼主分析一下如何解决问题。这道题本身计算很简单，不存在难度，难度是夸线程的数据交换，那就是搜索然后学习好了
for循环创建10个线程，并把计算范围传进去，
每个线程都返回自己的计算结果
主线程再统计结果
public class Test8 {
/**
* @param args
*/
public static void main(String[] args) {
My_Thread r=new My_Thread();
for(int i=0;i<10;i++){
Thread t=new Thread(r);
t.setName("线程"+i);
t.start();
try {
t.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+":"+r.getCount());
}
}
class My_Thread implements Runnable{
//共享数据
private int i=0;
//共享数据 统计总数
private int count=0;
public int getCount() {
return count;
}
@Override
public void run() {
//同步块
//synchronized (this) {
for(int j=1;j<=10;j++){
count=count+j+(i*10);
}
i++;
System.out.println(Thread.currentThread().getName()+":"+count);
//}
}
}