我对线程失去了理智
Im losing my mind with threads
我想要这个class的对象：
public class Chromosome implements Runnable, Comparable<Chromosome> {
private String[] chromosome;
public double fitness;
private Random chromoGen;
public Chromosome(double[] candidate) {
super();
//encode candidate PER parameter; using Matrix as storage
chromosome = encode(candidate);
chromoGen = new Random();
}
//De-fault
public Chromosome() {
super();
chromoGen = new Random();
//de-fault genotype
chromosome = new String[6];
}
/**
* IMPLEMENTED
*/
public void run() {
//I hope leaving it empty works...
}
public int compareTo(Chromosome c) {
return (int) (fitness - c.fitness);
}
/**
* Fitness stored in chromosome!
*/
public void setFitness(ArrayList<double[]> target) {
fitness = FF.fitness(this, target);
}
public double getFitness() {
return fitness;
}
/**
* ENCODERS/DECODERS
*/
public String[] encode(double[] solution) {
//subtract 2^n from solution until you reach 2^-n
/**
* LENGTH: 51 BITS!!
*
* 1st BIT IS NEGATIVE/POSITIVE
*
* THE PRECISION IS [2^30 <-> 2^-20]!!!
*
* RANGE: -2.14748...*10^9 <-> 2.14748...*10^9
*/
String[] encoded = new String[6];
//PER PARAMETER
for (int j = 0; (j < 6); j++) {
encoded[j] = encode(solution[j]);
}
return encoded;
}
public String encode(double sol) {
/**
* THE PRECISION IS [2^30 <-> 2^-20]!!!
*/
double temp = sol;
String row = "";
//NEGATIVITY CHECK
if (temp < 0) {
//negative
row = "1";
} else {
//positive
row = "0";
}
//main seq.
for (int n = 30; (n > (-21)); n--) {
if ((temp - Math.pow(2, n)) >= 0) {
temp = temp - Math.pow(2, n);
row = row + "1";
} else {
row = row + "0";
}
}
return row;
}
public double decoded(int position) {
//returns UN-ENCODED solution
double decoded = 0.00;
char[] encoded = (chromosome[position]).toCharArray();
/**
* [n?][<--int:30-->][.][<--ratio:20-->]
*/
int n = 30;
for (int i = 1; (i < encoded.length); i++) {
if (encoded[i] == '1') {
decoded += Math.pow(2, n);
}
//next binary-place
n--;
}
//NEGATIVE??
if (encoded[0] == '1') {
decoded = ((-1) * decoded);
}
//Output
return decoded;
}
/**
* GETTERS
* ---------------\/--REDUNDANT!!
*/
public double getParameter(int parameter) {
//decoded solution
return decoded(parameter);
}
/**
* Used in E-algrm.
*/
public String getRow(int row) {
//encoded solution
return chromosome[row];
}
/**
* SETTERS
*/
public void setRow(String encoded, int row) {
chromosome[row] = encoded;
}
public void setRow(double decoded, int row) {
chromosome[row] = encode(decoded);
}
/**
* MUTATIONS
*/
public void mutate(double mutationRate) {
//range of: 51
double ran = 0;
int r;
char[] temp;
for (int m = 0; (m < 6); m++) {
temp = (chromosome[m]).toCharArray();
ran = chromoGen.nextDouble();
if (ran <= mutationRate) {
r = chromoGen.nextInt(51);
if (temp[r] == '1') {
temp[r] = '0';
} else {
temp[r] = '1';
}
}
//output
chromosome[m] = new String(temp);
}
}
}
...在单独的线程中；但是我不需要方法 run();但是当我尝试这样做时：
child1 = new Chromosome();
(new Thread(child1)).start();
不过，我在 运行 时看到的唯一线程是 main()。
那么，我怎样才能让它成为独立的线程呢？？
当你调用Thread.start()时，新线程会从执行运行()方法开始，你应该在运行()中写下线程要做的事情方法，在 Thread 完成 运行() 方法后终止，因此它不再 运行ning 或可见。
当你有空的 运行() 方法时，它会立即完成，因为它没有任何作用。
线程应该做什么，应该调用什么？只需将该调用放入 运行() 方法即可。
试试这个，也许它会像你期望的那样工作，但我只是猜测你想将你在构造函数中处理的内容移动到一个线程中。
public class Chromosome implements Runnable, Comparable<Chromosome>
{
private String[] chromosome;
public double fitness;
private Random chromoGen;
private double[] candidate;
public Chromosome(double[] candidate)
{
super();
this.candidate=candidate;
}
//De-fault
public Chromosome()
{
super();
}
/**
* IMPLEMENTED
*/
public void run()
{
if (candidate!=null) {
//encode candidate PER parameter; using Matrix as storage
chromosome = encode(candidate);
chromoGen = new Random();
} else {
chromoGen = new Random();
//de-fault genotype
chromosome = new String[6];
}
}
public int compareTo(Chromosome c)
{
return (int)(fitness - c.fitness);
}
/**
* Fitness stored in chromosome!
*/
public void setFitness(ArrayList<double[]> target)
{
fitness = FF.fitness(this, target);
}
public double getFitness()
{
return fitness;
}
/**
* ENCODERS/DECODERS
*/
public String[] encode(double[] solution)
{
//subtract 2^n from solution until you reach 2^-n
/**
* LENGTH: 51 BITS!!
*
* 1st BIT IS NEGATIVE/POSITIVE
*
* THE PRECISION IS [2^30 <-> 2^-20]!!!
*
* RANGE: -2.14748...*10^9 <-> 2.14748...*10^9
*/
String[] encoded = new String[6];
//PER PARAMETER
for (int j = 0; (j < 6); j++){
encoded[j] = encode(solution[j]);
}
return encoded;
}
public String encode(double sol)
{
/**
* THE PRECISION IS [2^30 <-> 2^-20]!!!
*/
double temp = sol;
String row = "";
//NEGATIVITY CHECK
if (temp < 0){
//negative
row = "1";
}
else{
//positive
row = "0";
}
//main seq.
for (int n = 30; (n > (-21)); n--){
if ((temp - Math.pow(2, n)) >= 0){
temp = temp - Math.pow(2, n);
row = row+"1";
}
else{
row = row+"0";
}
}
return row;
}
public double decoded(int position)
{
//returns UN-ENCODED solution
double decoded = 0.00;
char[] encoded = (chromosome[position]).toCharArray();
/**
* [n?][<--int:30-->][.][<--ratio:20-->]
*/
int n = 30;
for (int i = 1; (i < encoded.length); i++){
if (encoded[i] == '1'){
decoded += Math.pow(2, n);
}
//next binary-place
n--;
}
//NEGATIVE??
if (encoded[0] == '1'){
decoded = ((-1)*decoded);
}
//Output
return decoded;
}
/**
* GETTERS
* ---------------\/--REDUNDANT!!
*/
public double getParameter(int parameter)
{
//decoded solution
return decoded(parameter);
}
/**
* Used in E-algrm.
*/
public String getRow(int row)
{
//encoded solution
return chromosome[row];
}
/**
* SETTERS
*/
public void setRow(String encoded, int row)
{
chromosome[row] = encoded;
}
public void setRow(double decoded, int row)
{
chromosome[row] = encode(decoded);
}
/**
* MUTATIONS
*/
public void mutate(double mutationRate)
{
//range of: 51
double ran = 0;
int r;
char[] temp;
for (int m = 0; (m < 6); m++){
temp = (chromosome[m]).toCharArray();
ran = chromoGen.nextDouble();
if (ran <= mutationRate){
r = chromoGen.nextInt(51);
if (temp[r] == '1'){
temp[r] = '0';
}
else{
temp[r] = '1';
}
}
//output
chromosome[m] = new String(temp);
}
}
}
我发现您对线程工作原理的理解有问题。
创建线程时，它会查找方法 run()。有几种创建线程的方法。我通过传递一个 Runnable 对象来做到这一点。
Thread t=new Thread (new Runnable);
你知道一个线程有多长吗？
- 只要方法
run() 存在并运行，线程就会存在。线程只执行 run() 方法中的代码。它不是为了在 run() 之外执行任何事情而设计的。当控件移出 run(). 时线程终止
您的情况：
您将 run() 方法留空了。因此，线程什么都不执行，并在创建时死亡。
你能做什么？
将程序的其余部分包含在 run() 中，以便 run() 保留在堆上，因此，新创建的线程运行程序。
您不需要将所有内容都放入 run()，您只需将第一个方法调用转移到 run()，以便它保留在堆上。
举个例子：
public class threading implements Runnable
{
public static void main(String args[])
{
Thread t = new Thread (new Runnable);
t.setName("thread1");
t.start();
print1();
print2();
}
public static void print2()
{
System.out.println(Thread.getName());
}
public static void print1()
{
System.out.println(Thread.getName());
}
public void run()
{
System.out.println(Thread.getName());
}
}
输出：
- 线程 1
- 主要
- 主要
是时候让你的新线程一直活跃到最后了。
public class threading implements Runnable
{
public static void main(String args[])
{
Thread t = new Thread (new Runnable);
t.setName("thread1");
t.start();
}
public static void print2()
{
System.out.println(Thread.getName());
}
public static void print1()
{
System.out.println(Thread.getName());
print2();
}
public void run()
{
System.out.println(Thread.getName());
print1();
}
}
输出：
- 线程 1
- 线程 1
- 线程 1
我们通过在 run() 中调用方法将方法 run() 保留在堆上。这种方法是进一步保持流量的方法。
我认为你的线程很好并且必须工作，但是你的 run 方法是空的并且线程在你没有注意到的情况下终止了
试试这个：
public void run()
{
System.out.println("I hope leaving it empty works...");
}
如果您在 console 中看到消息，那么一切都很好，您只需要在 run 方法中添加一个 condition/loop/logic，这样它就不会在之前被终止你完成了工作。
我想要这个class的对象：
public class Chromosome implements Runnable, Comparable<Chromosome> {
private String[] chromosome;
public double fitness;
private Random chromoGen;
public Chromosome(double[] candidate) {
super();
//encode candidate PER parameter; using Matrix as storage
chromosome = encode(candidate);
chromoGen = new Random();
}
//De-fault
public Chromosome() {
super();
chromoGen = new Random();
//de-fault genotype
chromosome = new String[6];
}
/**
* IMPLEMENTED
*/
public void run() {
//I hope leaving it empty works...
}
public int compareTo(Chromosome c) {
return (int) (fitness - c.fitness);
}
/**
* Fitness stored in chromosome!
*/
public void setFitness(ArrayList<double[]> target) {
fitness = FF.fitness(this, target);
}
public double getFitness() {
return fitness;
}
/**
* ENCODERS/DECODERS
*/
public String[] encode(double[] solution) {
//subtract 2^n from solution until you reach 2^-n
/**
* LENGTH: 51 BITS!!
*
* 1st BIT IS NEGATIVE/POSITIVE
*
* THE PRECISION IS [2^30 <-> 2^-20]!!!
*
* RANGE: -2.14748...*10^9 <-> 2.14748...*10^9
*/
String[] encoded = new String[6];
//PER PARAMETER
for (int j = 0; (j < 6); j++) {
encoded[j] = encode(solution[j]);
}
return encoded;
}
public String encode(double sol) {
/**
* THE PRECISION IS [2^30 <-> 2^-20]!!!
*/
double temp = sol;
String row = "";
//NEGATIVITY CHECK
if (temp < 0) {
//negative
row = "1";
} else {
//positive
row = "0";
}
//main seq.
for (int n = 30; (n > (-21)); n--) {
if ((temp - Math.pow(2, n)) >= 0) {
temp = temp - Math.pow(2, n);
row = row + "1";
} else {
row = row + "0";
}
}
return row;
}
public double decoded(int position) {
//returns UN-ENCODED solution
double decoded = 0.00;
char[] encoded = (chromosome[position]).toCharArray();
/**
* [n?][<--int:30-->][.][<--ratio:20-->]
*/
int n = 30;
for (int i = 1; (i < encoded.length); i++) {
if (encoded[i] == '1') {
decoded += Math.pow(2, n);
}
//next binary-place
n--;
}
//NEGATIVE??
if (encoded[0] == '1') {
decoded = ((-1) * decoded);
}
//Output
return decoded;
}
/**
* GETTERS
* ---------------\/--REDUNDANT!!
*/
public double getParameter(int parameter) {
//decoded solution
return decoded(parameter);
}
/**
* Used in E-algrm.
*/
public String getRow(int row) {
//encoded solution
return chromosome[row];
}
/**
* SETTERS
*/
public void setRow(String encoded, int row) {
chromosome[row] = encoded;
}
public void setRow(double decoded, int row) {
chromosome[row] = encode(decoded);
}
/**
* MUTATIONS
*/
public void mutate(double mutationRate) {
//range of: 51
double ran = 0;
int r;
char[] temp;
for (int m = 0; (m < 6); m++) {
temp = (chromosome[m]).toCharArray();
ran = chromoGen.nextDouble();
if (ran <= mutationRate) {
r = chromoGen.nextInt(51);
if (temp[r] == '1') {
temp[r] = '0';
} else {
temp[r] = '1';
}
}
//output
chromosome[m] = new String(temp);
}
}
}
...在单独的线程中；但是我不需要方法 run();但是当我尝试这样做时：
child1 = new Chromosome();
(new Thread(child1)).start();
不过，我在 运行 时看到的唯一线程是 main()。
那么，我怎样才能让它成为独立的线程呢？？
当你调用Thread.start()时，新线程会从执行运行()方法开始，你应该在运行()中写下线程要做的事情方法，在 Thread 完成 运行() 方法后终止，因此它不再 运行ning 或可见。
当你有空的 运行() 方法时，它会立即完成，因为它没有任何作用。 线程应该做什么，应该调用什么？只需将该调用放入 运行() 方法即可。
试试这个，也许它会像你期望的那样工作，但我只是猜测你想将你在构造函数中处理的内容移动到一个线程中。
public class Chromosome implements Runnable, Comparable<Chromosome>
{
private String[] chromosome;
public double fitness;
private Random chromoGen;
private double[] candidate;
public Chromosome(double[] candidate)
{
super();
this.candidate=candidate;
}
//De-fault
public Chromosome()
{
super();
}
/**
* IMPLEMENTED
*/
public void run()
{
if (candidate!=null) {
//encode candidate PER parameter; using Matrix as storage
chromosome = encode(candidate);
chromoGen = new Random();
} else {
chromoGen = new Random();
//de-fault genotype
chromosome = new String[6];
}
}
public int compareTo(Chromosome c)
{
return (int)(fitness - c.fitness);
}
/**
* Fitness stored in chromosome!
*/
public void setFitness(ArrayList<double[]> target)
{
fitness = FF.fitness(this, target);
}
public double getFitness()
{
return fitness;
}
/**
* ENCODERS/DECODERS
*/
public String[] encode(double[] solution)
{
//subtract 2^n from solution until you reach 2^-n
/**
* LENGTH: 51 BITS!!
*
* 1st BIT IS NEGATIVE/POSITIVE
*
* THE PRECISION IS [2^30 <-> 2^-20]!!!
*
* RANGE: -2.14748...*10^9 <-> 2.14748...*10^9
*/
String[] encoded = new String[6];
//PER PARAMETER
for (int j = 0; (j < 6); j++){
encoded[j] = encode(solution[j]);
}
return encoded;
}
public String encode(double sol)
{
/**
* THE PRECISION IS [2^30 <-> 2^-20]!!!
*/
double temp = sol;
String row = "";
//NEGATIVITY CHECK
if (temp < 0){
//negative
row = "1";
}
else{
//positive
row = "0";
}
//main seq.
for (int n = 30; (n > (-21)); n--){
if ((temp - Math.pow(2, n)) >= 0){
temp = temp - Math.pow(2, n);
row = row+"1";
}
else{
row = row+"0";
}
}
return row;
}
public double decoded(int position)
{
//returns UN-ENCODED solution
double decoded = 0.00;
char[] encoded = (chromosome[position]).toCharArray();
/**
* [n?][<--int:30-->][.][<--ratio:20-->]
*/
int n = 30;
for (int i = 1; (i < encoded.length); i++){
if (encoded[i] == '1'){
decoded += Math.pow(2, n);
}
//next binary-place
n--;
}
//NEGATIVE??
if (encoded[0] == '1'){
decoded = ((-1)*decoded);
}
//Output
return decoded;
}
/**
* GETTERS
* ---------------\/--REDUNDANT!!
*/
public double getParameter(int parameter)
{
//decoded solution
return decoded(parameter);
}
/**
* Used in E-algrm.
*/
public String getRow(int row)
{
//encoded solution
return chromosome[row];
}
/**
* SETTERS
*/
public void setRow(String encoded, int row)
{
chromosome[row] = encoded;
}
public void setRow(double decoded, int row)
{
chromosome[row] = encode(decoded);
}
/**
* MUTATIONS
*/
public void mutate(double mutationRate)
{
//range of: 51
double ran = 0;
int r;
char[] temp;
for (int m = 0; (m < 6); m++){
temp = (chromosome[m]).toCharArray();
ran = chromoGen.nextDouble();
if (ran <= mutationRate){
r = chromoGen.nextInt(51);
if (temp[r] == '1'){
temp[r] = '0';
}
else{
temp[r] = '1';
}
}
//output
chromosome[m] = new String(temp);
}
}
}
我发现您对线程工作原理的理解有问题。
创建线程时，它会查找方法 run()。有几种创建线程的方法。我通过传递一个 Runnable 对象来做到这一点。
Thread t=new Thread (new Runnable);
你知道一个线程有多长吗？
- 只要方法
run()存在并运行，线程就会存在。线程只执行run()方法中的代码。它不是为了在run()之外执行任何事情而设计的。当控件移出run(). 时线程终止
您的情况：
您将 run() 方法留空了。因此，线程什么都不执行，并在创建时死亡。
你能做什么？
将程序的其余部分包含在 run() 中，以便 run() 保留在堆上，因此，新创建的线程运行程序。
您不需要将所有内容都放入 run()，您只需将第一个方法调用转移到 run()，以便它保留在堆上。
举个例子：
public class threading implements Runnable
{
public static void main(String args[])
{
Thread t = new Thread (new Runnable);
t.setName("thread1");
t.start();
print1();
print2();
}
public static void print2()
{
System.out.println(Thread.getName());
}
public static void print1()
{
System.out.println(Thread.getName());
}
public void run()
{
System.out.println(Thread.getName());
}
}
输出：
- 线程 1
- 主要
- 主要
是时候让你的新线程一直活跃到最后了。
public class threading implements Runnable
{
public static void main(String args[])
{
Thread t = new Thread (new Runnable);
t.setName("thread1");
t.start();
}
public static void print2()
{
System.out.println(Thread.getName());
}
public static void print1()
{
System.out.println(Thread.getName());
print2();
}
public void run()
{
System.out.println(Thread.getName());
print1();
}
}
输出：
- 线程 1
- 线程 1
- 线程 1
我们通过在 run() 中调用方法将方法 run() 保留在堆上。这种方法是进一步保持流量的方法。
我认为你的线程很好并且必须工作，但是你的 run 方法是空的并且线程在你没有注意到的情况下终止了
试试这个：
public void run()
{
System.out.println("I hope leaving it empty works...");
}
如果您在 console 中看到消息，那么一切都很好，您只需要在 run 方法中添加一个 condition/loop/logic，这样它就不会在之前被终止你完成了工作。