Einen wiederverwendbaren Thread selber schreiben

Mich würde interessieren, was ihr von meinem Ansatz haltet:

public class MyBot implements Runnable {
	public volatile boolean isActive = false;

	@Override
	public void run() {
		while (!Thread.interrupted()) {
			if (isActive) {
				System.out.println("Bot activated at: " + new Date(System.currentTimeMillis()));

				// The bot logic here or time intensive operations ...

				for (int i = 0; i < 120; i++) {
					try {
						Thread.sleep(5000);
					} catch (InterruptedException e1) {
						System.out.println(e1.getMessage());
					}
					if (!isActive) {
						break;
					}
				}
			} else {
				try {
					Thread.sleep(5000);
				} catch (InterruptedException e1) {
					System.out.println(e1.getMessage());
				}
			}
		}
	}
}
MyBot mybot = new MyBot();
Thread mybotthread = new Thread(mybot);
mybotthread.start();
mybot.isActive = true;

Der Thread soll immer laufen. Nun kann ich ihn mit mybot.isActive = true; (re)aktivieren und ihn mit mybot.isActive = false; deaktivieren. Ist das eine gute Vorgehensweise, auch hinsichtlich der sleep-Anweisungen?

Nein. Vielleicht mal was um Condition (Java Platform SE 8 ) herum lesen, aber je nachdem, was das sein soll, gibt es vielleicht geeignetere Ansätze.

Ja, wäre besser, damit habe ich mich in dem Zusammenhang aber noch nicht befasst.

Auf das Release einer Semaphore (https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html) warten, ist dabei ganz praktisch…

public class MyRunna implements Runnable {
	public Semaphore sem = new Semaphore(1);
	private int index = 1;

	@Override
	public void run() {
		while (!Thread.interrupted()) {
			try {
				sem.acquire();

				System.out.println(index++);
				Thread.sleep(1000);

				sem.release();
			} catch (InterruptedException e1) {
				e1.printStackTrace();
			}
		}
	}

	public void nextStart() {
		sem.release();
	}

	public void nextStop() {
		try {
			sem.acquire();
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
	}
}

		try {
			MyRunna mr = new MyRunna();
			new Thread(mr).start();
			System.out.println("sleep 5000 1");
			Thread.sleep(5000);

			mr.nextStop();
			System.out.println("sleep 10000 2");
			Thread.sleep(10000);

			mr.nextStart();
			System.out.println("sleep 5000 3");
			Thread.sleep(5000);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}

		System.exit(0);
sleep 5000 1
1
2
3
4
5
sleep 10000 2
6
sleep 5000 3
7
8
9
10

*kopfschüttel* Wie weit willst du denn hier gerade runter?

Ich will was mit Threads machen. Was haltet ihr denn von dieser Lösung

Thread iîìI= new Thread(() -> {
     try {
         System.out.println("Did something with threads!");
     } catch (Exception wontBeSoBad) {}
});
iîìI.start();

Das funktioniert! Aber kann man das noch verbessern?

In Bezug auf was genau?

Edit: Wenn du meine Frage nicht gelesen hast, versuch es nochmal zu lesen.

Ich habe deine „„Frage““ gelesen und beantwortet. Kann hier dann jetzt zugemacht werden? :roll_eyes:

Von mir aus.