minte9
LearnRemember



SLEEP

One of the best ways to help your threads take turns is by using sleep. 
 
/**
 * One of the best ways to help your threads take turns is ...
 * by using sleep.
 * 
 * The main thread will became the current running tread.
 */

package com.minte9.threads.sleep;

public class Sleep {    
    public static void main(String[] args) 
                        throws InterruptedException {
        
        System.out.println("Start in main");

        new Thread(new MyClass(1)).start();
        new Thread(new MyClass(2)).start();
        new Thread(new MyClass(3)).start();
        
        System.out.println("Back in main");

        /* 
            Start in main
            Back in main
            Thread 1 / run
            Thread 3 / run
            Thread 2 / run
        */
    }
}

class MyClass implements Runnable {

    int no = 0;
    public MyClass(int i) { 
        no = i; 
    }
    
    @Override public void run() {
        try {
            Thread.sleep(1000);  // Look Here

        } catch(InterruptedException e) {}
        System.out.println("Thread " + no + " / run");
    }
}

STOP

Use a flag to stop a thread run() execution. 
 
/**
 * A thread is automatically destroyed when the run() method has completed.
 * 
 * You might need to stop a thread on runtime.
 * Use a flag to control thread run() execution.
 */

package com.minte9.threads.sleep;

public class Stop {
    public static void main(String[] args) 
                        throws InterruptedException {

        System.out.println("Start main thread");

        ThreadClass t1 = new ThreadClass("A");
        ThreadClass t2 = new ThreadClass("B");
        
        new Thread(t1).start();
        new Thread(t2).start();
        Thread.sleep(2000); 

        t1.stop();
        t2.stop();

        Thread.sleep(1000); 
        System.out.println("Exit main thread");

        /*
            Start main thread
            Thread A / Run
            Thread B / Run
            Thread A / Run
            Thread B / Run
            Thread A / Exit
            Thread B / Exit
            Exit main thread
        */
    }
}

class ThreadClass implements Runnable {

    private String name;
    private Boolean exit = false;

    public ThreadClass(String n) { 
        name = n; 
    }

    @Override public void run() {

        while(!exit) {
            System.out.println("Thread " + name + " / Run");
            sleep(1000);
        }
        
        System.out.println("Thread " + name + " / Exit");
    }

    public void sleep(int ms) {
        try { 
            Thread.sleep(ms); 
        } catch (InterruptedException e) {}
    }

    public void stop() {
        exit = true;
    }
}



  Last update: 314 days ago