使用新參數在循環中創建新線程

Question

我想在循環中創建新的Runnable 。 但是，不可能在內部類中使用變量。 我不能使用全局/實例變量，因為它會產生錯誤的結果。 我的程序類似於下面的簡化代碼：

public class RunManager {
    public void runManager(int delay, final Context context) {
        for (int dim = 7; dim < 227; dim++) {
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, dim);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }
            };
            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

錯誤是： Variable 'dim' is accessed from within inner class, needs to be declared final.

Answer 1

您的問題是您正在嘗試從新線程訪問非最終變量。 為了從新線程訪問變量，需要將其聲明為final。 在您的cas中，您可以將dim int復制到大小為1的最終int數組，然后從線程訪問該數組。

Answer 2

可能最清晰的方法是為Runnable創建一個接受int作為參數的構造函數。 如：

public class MyRunnable implements Runnable {

   public MyRunnable(Context context, int dim) {
       // save parameters as class variables
   }

   public void run() {
       // do the work
   }
}

然后調用它：

Runnable r = new MyRunnable(context, dim);
new Thread(r).start();

Answer 3

如果要訪問內部類中的值，則應使用final int[] dim 。

public class RunManager {

    public void runManager(int delay, final Context context) {
        for (final int dim[] = {7}; dim[1] < 227; dim[1]++) {
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, dim[1]);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }
            };
            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

選項2-使用字段：

public class RunManager {

    private int _dim;

    public void runManager(int delay, final Context context) {
        for (int dim = 7; dim < 227; dim++) {
            _dim = dim;
            Runnable r = new Runnable() {
                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, _dim);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }
            };
            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

選項3-迭代另一個方法，並添加final int dim作為方法參數：

private void createThreads(int delay, final Object context) {
    for (int dim = 7; dim < 227; dim++) {
        runManager(delay, context, dim);
    }
}

public void runManager(int delay, final Context context, final int dim) {
    Runnable r = new Runnable() {
        @Override
        public void run() {
            RandomKernels randomKernels = new RandomKernels();
            try {
                randomKernels.foo(context, dim);
            } catch (InterruptedException e) {
                Log.e(tag, e.getMessage());
            }
        }
    };
    Thread cnnThread = new Thread(r);
    cnnThread.start();
    try {
        Thread.sleep(delay);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

選項4-使用自定義可運行。 您可以按照@BMacedo的建議實現類，也可以創建抽象類並在內部類中實現邏輯。

public class RunManager {

    public void runManager(int delay, final Context context) {
        for (int dim = 7; dim < 227; dim++) {
            CustomRunnable r = new CustomRunnable() {
                private int _dim;

                @Override
                public void run() {
                    RandomKernels randomKernels = new RandomKernels();
                    try {
                        randomKernels.foo(context, _dim);
                    } catch (InterruptedException e) {
                        Log.e(tag, e.getMessage());
                    }
                }

                public void setDim(int dim) {
                    _dim = dim;
                }
            };

            r.setDim(dim);

            Thread cnnThread = new Thread(r);
            cnnThread.start();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    abstract class CustomRunnable implements Runnable {
        public abstract void setDim(int dim);
    }
}