Java多线程对象
我正在尝试用java对一些算法进行建模，我现在面临的是，我需要将算法的主要部分运行10次，但这个过程需要120分钟才能完成，所以我在一个线程上运行每一次。我想要的是创建10个线程，而不是在每个线程中重复相同的代码，因此如何使用相同的代码创建10个不同的线程来执行。任何想法Java多线程对象,java,multithreading,object,Java,Multithreading,Object,我正在尝试用java对一些算法进行建模，我现在面临的是，我需要将算法的主要部分运行10次，但这个过程需要120分钟才能完成，所以我在一个线程上运行每一次。我想要的是创建10个线程，而不是在每个线程中重复相同的代码，因此如何使用相同的代码创建10个不同的线程来执行。任何想法 package biodavidcorne; import java.util.Random; /** * * @author hyder */ public class BIODavidCorne extends T
package biodavidcorne;
import java.util.Random;
/**
*
* @author hyder
*/
public class BIODavidCorne extends Thread {
public void run(int Runs) {
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
BIODavidCorne test = new BIODavidCorne();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
try {
int Runs = 0;
int[][] Mean10Runs = new int[10][10000];
int[][] Min10Runs = new int[10][10000];
int[][] Max10Runs = new int[10][10000];
// for (int Runs = 0; Runs < 10; Runs++) {
BinList test = new BinList();
Random generator = new Random();
for (int i = 0; i < 10; i++) {
test.ReadLine("File.txt", i);
}
//test.PrintListOfGarbage();
for (int i = 0; i < 10; i++) {
test.InsertGarbageToBin(i);
}
for (int Big = 0; Big < 10000; Big++) {
int Mean = 0;
for (int x = 0; x < 10; x++) {
for (int i = 0; i < 50; i++) {
test.GetPenalties(x, i);
}
}
// System.out.println("*******************************************************************************************" + Big + " .. " + Runs);
// test.PrintListOfGarbage();
int[] penalty = new int[10];
int[] minimum = new int[10];
int[] maximum = new int[10];
int[] mutation = new int[10];
// test.PrintListOfGarbage();
for (int i = 0; i < 10; i++) {
penalty[i] = test.getAllPanalties(i);
}
for (int i = 0; i < 10; i++) {
minimum[i] = test.getMinimum(i);
maximum[i] = test.getMaximum(i);
mutation[i] = test.calculateMutation(penalty[i], minimum[i], maximum[i]);
//
}
int r = generator.nextInt(10);
int s = generator.nextInt(10);
test.MakeTheFitness(mutation, r, s);
test.resetPenaltyArray();
// test.PrintListOfGarbage();
for (int i = 0; i < 10; i++) {
Mean = Mean + mutation[i];
}
int min = mutation[0];
int max = 0;
for (int i = 0; i < 10; i++) {
if (min > mutation[i]) {
min = mutation[i];
}
if (max < mutation[i]) {
max = mutation[i];
}
}
Min10Runs[Runs][Big] = min;
Max10Runs[Runs][Big] = max;
Mean10Runs[Runs][Big] = (Mean / 10);
System.out.println("This is the Mean 1"+Big+".."+Runs);
}
System.out.println("This is the Mean + for Runs" + Runs + ".. " + Mean10Runs[Runs][9999] + "This is the Minimum " + Min10Runs[Runs][9999]);
} catch (Exception e) {
System.out.println("Not supported yet." + e);
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
try {
int Runs = 0;
int[][] Mean10Runs = new int[10][10000];
int[][] Min10Runs = new int[10][10000];
int[][] Max10Runs = new int[10][10000];
// for (int Runs = 0; Runs < 10; Runs++) {
BinList test = new BinList();
Random generator = new Random();
for (int i = 0; i < 10; i++) {
test.ReadLine("File.txt", i);
}
//test.PrintListOfGarbage();
for (int i = 0; i < 10; i++) {
test.InsertGarbageToBin(i);
}
for (int Big = 0; Big < 10000; Big++) {
int Mean = 0;
for (int x = 0; x < 10; x++) {
for (int i = 0; i < 50; i++) {
test.GetPenalties(x, i);
}
}
// System.out.println("*******************************************************************************************" + Big + " .. " + Runs);
// test.PrintListOfGarbage();
int[] penalty = new int[10];
int[] minimum = new int[10];
int[] maximum = new int[10];
int[] mutation = new int[10];
// test.PrintListOfGarbage();
for (int i = 0; i < 10; i++) {
penalty[i] = test.getAllPanalties(i);
}
for (int i = 0; i < 10; i++) {
minimum[i] = test.getMinimum(i);
maximum[i] = test.getMaximum(i);
mutation[i] = test.calculateMutation(penalty[i], minimum[i], maximum[i]);
//
}
int r = generator.nextInt(10);
int s = generator.nextInt(10);
test.MakeTheFitness(mutation, r, s);
test.resetPenaltyArray();
// test.PrintListOfGarbage();
for (int i = 0; i < 10; i++) {
Mean = Mean + mutation[i];
}
int min = mutation[0];
int max = 0;
for (int i = 0; i < 10; i++) {
if (min > mutation[i]) {
min = mutation[i];
}
if (max < mutation[i]) {
max = mutation[i];
}
}
Min10Runs[Runs][Big] = min;
Max10Runs[Runs][Big] = max;
Mean10Runs[Runs][Big] = (Mean / 10);
System.out.println("This is the Mean 2"+Big+".."+Runs);
}
} catch (Exception e) {
System.out.println("Not supported yet." + e);
}
}
});
t1.start();
t2.start();
}
class MyRunnable implements Runnable {
@Override
public void run() {
int Runs = 0;
int[][] Mean10Runs = new int[10][10000];
// ...
new Thread(new MyRunnable()).start();
class MyRunnable implements Runnable {
@Override
public void run() {
int Runs = 0;
int[][] Mean10Runs = new int[10][10000];
// ...
new Thread(new MyRunnable()).start();
您可以而且应该将MyRunnable放在它自己的源文件中。没有理由复制并粘贴匿名内部类的内容十次。只需将其分配给一个变量并使用10次即可
Runnable runnable = new Runnable() {
@Override
public void run() {
// ... the code in the anonymous inner class
}
}
// Start 10 threads with this code
for (int i = 0; i < 10; ++i) {
new Thread(runnable).start();
}
没有理由复制并粘贴匿名内部类的内容十次。只需将其分配给一个变量并使用10次即可
Runnable runnable = new Runnable() {
@Override
public void run() {
// ... the code in the anonymous inner class
}
}
// Start 10 threads with this code
for (int i = 0; i < 10; ++i) {
new Thread(runnable).start();
}
尝试使用ThreadPoolExecutor
尝试使用ThreadPoolExecutor
您可以使用for循环来创建线程。 此外，如果希望确保所有线程同时启动，可以使用CyclicBarrier，但如果不希望，则可以在创建每个线程时启动它 如果需要保存对线程的引用，请将它们存储在线程数组中
CyclicBarrier barrier = new CyclicBarrrier(10);
Thread[] threads = new Thread[10];
for(int i = 0; i < 10; i++){
threads[i] = new Thread(runnable);
threads[i].start();
}
就这样！祝你好运-如果你需要帮助实现runnable，请告诉我。你可以使用for循环来创建线程。 此外，如果希望确保所有线程同时启动，可以使用CyclicBarrier，但如果不希望，则可以在创建每个线程时启动它 如果需要保存对线程的引用，请将它们存储在线程数组中
CyclicBarrier barrier = new CyclicBarrrier(10);
Thread[] threads = new Thread[10];
for(int i = 0; i < 10; i++){
threads[i] = new Thread(runnable);
threads[i].start();
}
就这样！祝你好运-如果需要帮助实现runnable，请告诉我。创建一个扩展线程的类并实现run方法。您可以通过构造函数传递参数，将它们保留为成员，以便在run方法中使用它们 大概是这样的：
public class YourThread extends Thread{
private String mParam1;
private Object mParam2;
public YourThread( String param1, Object param2 ){
mParam1 = param1;
mParam2 = param2;
}
public void run(){
// do your stuff here
// ...
}
}
YourThread t1 = new Thread( "toto", new Object() );
t1.start();
YourThread t2 = new Thread( "titi", new Object() );
t2.start();
创建一个扩展线程的类并实现run方法。您可以通过构造函数传递参数，将它们保留为成员，以便在run方法中使用它们 大概是这样的：
public class YourThread extends Thread{
private String mParam1;
private Object mParam2;
public YourThread( String param1, Object param2 ){
mParam1 = param1;
mParam2 = param2;
}
public void run(){
// do your stuff here
// ...
}
}
YourThread t1 = new Thread( "toto", new Object() );
t1.start();
YourThread t2 = new Thread( "titi", new Object() );
t2.start();
除非你有10个CPU核心，否则不要产生10个线程
您可以使用它并将其设置为cpu核心数的大小，以便并行和顺序运行任务。除非您有10个cpu核心，否则不会产生10个线程
您可以使用它并将其设置为cpu核心数的大小，这样您就可以并行和顺序地运行任务。据我所知，您的算法是cpu密集型的，因此，在解决此问题之前，请确保至少有10个内核可用。运行一个算法实例的10个线程将比按顺序运行10个算法实例的1个线程花费更多的时间，除非JVM能够利用多个内核。在不了解程序架构的情况下，实际上不可能建议任何可能提高速度的更改。我会将内存分配移出内部循环，例如，在for循环之外声明惩罚、最小值、最大值等，并在每次迭代开始时将其归零。这可能会加快串行或线程化代码的速度。@mcfinnigan-现代JVM非常擅长在多核上执行线程化。Java有时用于高性能任务。@andrewmu不是我熟悉的域，因此我不确定JVM是否需要传递-X或-XX参数来启用多核使用。据我所知，您的算法是CPU密集型的，因此，在解决此问题之前，请确保至少有10个内核可用。运行一个算法实例的10个线程将比按顺序运行10个算法实例的1个线程花费更多的时间，除非JVM能够利用多个内核。在不了解程序架构的情况下，实际上不可能建议任何可能提高速度的更改。我会将内存分配移出内部循环，例如，在for循环之外声明惩罚、最小值、最大值等，并在每次迭代开始时将其归零。这可能会加快串行或线程化代码的速度。@mcfinnigan-现代JVM非常擅长在多核上执行线程化。Java有时用于高性能任务。@andrewmu不是我熟悉的域，因此我不确定JVM是否需要传递-X或-XX参数来启用多核使用。