Four ways to create multithreads

Catalog

Mode one ： Inherit Thread Kind of the way

Mode two 、 Realization Runnable How to interface

Mode three ： Realization Callable How to interface     Jdk5.0 Newly added

Mode 4 ： How to use thread pool

summary ： These do not consider whether the thread is safe , So the next chapter considers

---

 

Program 、 Threads 、 process

Program ： A piece of static code process ： A running program Threads ： Processes can be refined into threads , It's an execution path inside the program

Mode one ： Inherit Thread Kind of the way

 step ：
  Create an inheritance from Thread Subclasses of classes 
  rewrite run() Method ---> Write what this thread will do in the method body 
  Create subclass objects 
  Call... Through this object start()

// Traverse 100 An even number within 
class MyThread extends Thread {
    @Override
//     The execution of another thread 
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

class W {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
     }
}

Mode two 、 Realization Runnable How to interface

 step ：
 Created and implemented Runnable The class of the interface 
 Implement classes to implement Runnable Abstract methods in interfaces ：run()
 Create objects that implement classes 
 Pass this object as an argument to Thread In the constructor of class , establish Thread Class object 
 adopt Thread Class object call start() Method 

class MThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);// It has to be written like this 
//                 Because this implementation class is implemented Runnable, It doesn't have getName() Methods 
            }
        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args) {
//        3. Create objects that implement classes 
        MThread mThread = new MThread();
        
//        4. Pass this object as an argument to Thread In the constructor of class , establish Thread Class object 
        Thread t1 = new Thread(mThread);
//         Open another thread 
        Thread t2 = new Thread(mThread);

        t1.setName(" Thread one ");
        t2.setName(" Thread two ");

//        5. adopt Thread Class object call start() Method 
        t1.start();
        t2.start();
    }
}

Mode three ： Realization Callable How to interface     Jdk5.0 Newly added

 step ：
1. Create an implementation Callable Implementation class of interface 
2. Realization call(), Write the operations that the thread needs to implement in call() in 
3. Create objects that implement classes 
4. Pass the object of the implementation class as a parameter to FutureTask In the constructor of class , establish FutureTask Class object 
5. take FutureTask Object passed as a parameter to Thread In the constructor of class , establish Thread Class and call start().
6. If you want to call() The return value of , Just use FutureTask Class to call get() To get call() Return value in 

class NewThread implements Callable {
    //  2. Realization call(), Write the operations that the thread needs to implement in call() in 

    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
//        3. Create objects that implement classes 
        NewThread n = new NewThread();
//        4. Pass the object of the implementation class as a parameter to FutureTask In the constructor of class , establish FutureTask Class object 
        FutureTask f1 = new FutureTask(n);
//        5. take FutureTask Object passed as a parameter to Thread In the constructor of class , establish Thread Class and call start().
        new Thread(f1).start();

//      6. If you want to call() The return value of , Just use FutureTask Class to call get() To get call() Return value in 
        try {//get() The return value of FutureTask The constructor parameter of the Callable The implementation class of call() The value returned 
            Object sum = f1.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

Mode 4 ： How to use thread pool

 step ：
1. Create an implementation Runnable perhaps Callable Implementation class of 
2. Realization run() or call()
3. Provides a thread pool with a specified number of threads 
 If you need to operate on the thread pool , Forced to ThreadPoolExecutor Type and instantiate . Then you can operate 
4. Execute the operation of the specified thread , You need to provide an implementation Runnable perhaps Callable Interface implementation class object 
5. Close connection pool 

class Thread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

class Thread2 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

public class ThreadPool {
    public static void main(String[] args) {
//        1. Provides a thread pool with a specified number of threads 
        ExecutorService e = Executors.newFixedThreadPool(10);
//         When you need to operate on the thread pool , Forced to ThreadPoolExecutor Type and instantiate . Then you can operate 
        ThreadPoolExecutor e1 = (ThreadPoolExecutor) e;
        e1.setCorePoolSize(19);
//        2. Execute the operation of the specified thread , You need to provide an implementation Runnable perhaps Callable Interface implementation class object 
        e.execute(new Thread1());// Apply to Runnable
        e.execute(new Thread2());// Apply to Runnable

//        e.submit();// Apply to Callable

//        3. Close connection pool 
        e.shutdown();
    }
}

summary ： These do not consider whether the thread is safe , So the next chapter considers