در حالت عادی برنامه به صورت تک بعدی و از بالا به پایین اجرا می شود. در برنامه نویسی کاربرد thread به شکلی است که ما برنامه را از حالت تک بعدی خارج و به چند نخی به طوری که قابلیت اجرا همزمان چند thread را داشته باشیم.

در برنامه نویسی multiThreading ما هر کلاس را به صورت یک thread در می آوریم.در حالت عادی و تک بعدی هر کلاس (رویه موجود در کلاس ) به صورت ۱۰۰ درصد اجرا می شود و به سراغ مورد بعدی می رود. ولی در حالت multithreading هر هر کلاس (رویه موجود در کلاس ) به صورت یک thread در می آمد و با ترکیب چند thread دیگر به صورت همزمان اجرا می شوند . به طوری که مثلا ۱۰ درصد از thread اول اجرا شده و بعد به حالت wait در می آید و بعد به سراغ thread بعدی می رود و مثلا ۱۵ درصد از آن را اجرا می کند و به همین منوال ادامه پیدا می کند تا زمانی که تمامی thread ها به صورت ۱۰۰ درصد اجرا گردد و اصطلاحا مرحله خاتمه thread برسد.

پاسخگویی به درخواست های مختلف و به صورت همزمان اب اجرای همزمان چندین متد موجود در یک کلاس در قالب thread . این امر گاها در بازی سازی کاربرد دارد به صورتی که باید به صورت همزمان پاسخگوی حرکات کاربر باشیم.

چرخه حیات یک thread (Life Cycle of a Thread)

یک thread مراحل مختلفی را در طول برنامه و تا زمان خاتمه طی می کند. این مراحل جهت مدیریت thread ها برای اجرای همزمان آن ها توسط سیستم عامل اتفاق می افتد.

New : متولد شدن یک thread

Runnable : به حالت اجرا در آمدن thread

Waiting : گاهی اوقات یک thread تا اتمام کار thread دوم به حالت انتظار می رود.

Dead : خاتمه یک thread و زمانی که به حالت ۱۰۰ درصد در بیاید.

پیاده سازی یک Thread در جاوا

ما در جاوا یک کلاس را به یک thread نگاشت می کنیم و بعد thread بوجود آمده را با کنترل های مربوطه (متد های کلاس Thread) روی آن اجرا کنیم مثلا آن را به حالت خواب در بیاوریم یا سیستم عامل را مجبور به اجرای ۱۰۰ درصدی آن کنیم.

ابتدا باید یک کلاس از کلاس آماده Runnable به صورت implements در آوریم.

در کلاس موجود خود باید متد run را بسازیم. این متد در زمان استارت thread به اجرا در می آید.

بعد باید آن را به کلاس آماده Thread بدهیم تا کلاس موجود به شکل thread در بیاید.

• RUNABLECLASS : نام کلاسی است که از کلاس Runable موجود در جاوا implements شده باشد.
• THREADNAME : نام تخصیص داده شده برای thread موجود.

public class A implements Runnable{
    @Override
    public void run(){
        System.out.println("A");
    }
}
public class B implements Runnable {
    @Override
    public void run() {
        System.out.println("B");
    }
}
public class C implements Runnable {
    public void run(){
        System.out.println("C");
    }
}
public class MyClass {

    public static void main(String arg[]){
        //simple
        A a = new A();
        B b = new B();
        C c = new C();

        Thread athread = new Thread(a,"athread");
        Thread bthread = new Thread(b,"bthread");
        Thread cthread = new Thread(c,"cthread");

        athread.start();
        cthread.start();
        bthread.start();
    }
}

خروجی ما به صورت زیر خواهد بود :

A
C
B

همان طور که می بیندید ما نحوه اجرای thread ها را به سیستم عامل می سپاریم و ممکن است بدون ترتیب موجود در کد اجرا گردند.

متد های موجود در کلاس Thread

join : سیستم عامل را مجبور به اجرای کامل یک thread می کند. این متد باید در داخل بلوک try…catch قرار بگیرد.

public class D implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<6; i++){
            System.out.println(i);
        }
    }
}
public class MyClass {
    public static void main(String arg[]){
        D j1 = new D();
        D j2 = new D();
        D j3 = new D();

        Thread t1 = new Thread(j1,"number1");
        Thread t2 = new Thread(j2,"number2");
        Thread t3 = new Thread(j3,"number3");

        t1.start();
        try {
            t1.join();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        t2.start();
        t3.start();
    }
}

در کد بالا ابتدا کد های موجود در Thread t1 به اجرا در می آید بعد سایر را اجرا می کند. یعنی در ابتدای رشته ما اعداد 0 تا 5 را به ترتیب که مربوط به thread اول است را داریم.

sleep : این متد برای ایجاد وقفه در برنامه می باشد. به طوری که وقتی به اجرای thread مربوطه رسید وقفه ایجاد می شود.

public class D implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<6; i++){
            System.out.println(i);
        }
    }

}
public class MyClass2 {
    public static void main(String arg[]){
        D j1 = new D();
        D j2 = new D();
        D j3 = new D();

        Thread jthread1 = new Thread(j1,"number1");
        Thread jthread2 = new Thread(j2,"number2");
        Thread jthread3 = new Thread(j3,"number3");

        jthread1.start();
        try {
            jthread1.sleep(3000);
        }catch (InterruptedException e){
            e.getMessage();
        }

        jthread2.start();
        jthread3.start();

    }
}

در اینجا زمانی که به اجرای thread دوم می رسد یک وقفه 3000 میلی ثانیه ای اتفاق می افتد.

نکته : متد sleep صرف استفاده در Thread ها نیست . میتوانید در کلاس های معمولی خود از آن استفاده کنید.

public class sleep {
    public static void main(String arg[]){
        for(int i=0; i<10; i++){
            System.out.println(i);
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

در کد بالا در کنسول به ازای چاپ هر عدد 1000 میلی ثانیه وقفه اتفاق می افتد و بعد عدد بعدی چاپ می شود.

ایجاد Thread با استفاده از ارث بری از کلاس Thread

روش دوم ساخت یک thread ارث بری از کلاس Thread می باشد.

public class A extends Thread{

    public void run(){
        System.out.println("a");
     }
    public static void main(String arg[]){
        A a = new A();
        a.start();
    }
}