Разбиране на нишките, внедряващи Runnable в java

thread.run(); просто извиква вашия Runnables run метод директно, в контекста на текущата нишка. Ще получите същия резултат, ако просто бъдете извикани run() във вашия runThread метод.

Трябва да извикате thread.start(), това ще създаде нова процесна нишка и в крайна сметка ще извика вашия Runnables run метод

Вместо да опаковате Thread вместо Runnable, което е контраинтуитивно и като цяло с лош дизайн, трябва да създадете Thread и да зададете Runnable на него, когато трябва, например...

public class MyThread implements Runnable {
    private DataContainer dataContainer;
    public MyThread(DataContainer dataContainer) {
        this.dataContainer = dataContainer;
    }
    @Override
    public void run() {
        System.out.println("MyThread : "+dataContainer.toString());
    }
}

Тогава можете да направите нещо като...

DataContainer dataContainer = DataContainer.getInstance();
MyThread myThread = new MyThread(dataContainer);

Thread thread = new Thread(myThread );
thread.setName("Thread 2");
thread.start();

System.out.println("Launcher : " + dataContainer.toString());

myThread.runThread() просто ще извика този метод в текущата нишка. Ако искате това да се изпълни в нова нишка, поставете това извикване вrun метод и просто извикайте myThread.start(). Това стартира друга нишка и извиква метода за изпълнение на вашия изпълняваем обект.

Когато дефинирате клас, който имплементира Runnable, не е необходимо да имате обект Thread в него.

Опростено

 class myThread implements Runnable {

     @Override
    public void run() {
          // do something
   }
}


new Thread (new myThread ()).start ();

Не се опитах да разбера примера ви (твърде заплетен), но това е лоша идея:

public class Foobar implements Runnable {
    private XType x;
    private YType y;
    private Thread thread;

    public Foobar() {
        x = new XType();
        thread = new Thread(this);   //Not in a constructor!!!
        thread.start();
        y = new YType();
    }

    @Override
    public void run() {
        doSomethingWith(y);       // y can be uninitialized at this point.
        doSomethingElseWith(x);   // x can be uninitialized too!!!
    }
}

Този анти-шаблон има име, нарича се "изтичане на this от конструктор." Конструкторът на Foobar стартира новата нишка и й дава препратка към новия екземпляр на Foobar (т.е. this), преди новият обект да бъде напълно инициализиран. Спецификацията на езика Java не дава гаранции за това как ще изглежда обектът в новата нишка, когато обектът е публикуван по този начин. (Google за „безопасно публикуване“)

По-специално, когато методът run() е въведен за първи път, всяка от членските променливи на обекта (включително x!!) може да изглежда неинициализирана от гледна точка на новата нишка.

Най-добра практика: Никога не използвайте this в конструктор или в който и да е помощен метод, който се извиква от конструктора, и също така декларирайте помощниците като final, така че подкласът да не може да замени един и да види неинициализирания обект по този начин.

class Foobar {

    Foobar(...) {
        ...don't use "this" here...
        fooHelper(...);
    }

    private final void fooHelper(...) {
        ...don't use "this" here either...
    }
}