Shulou(Shulou.com)05/31 Report--

This article focuses on "how to create threads for Java concurrent programming". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to create threads of Java concurrent programming.

1. Thread and process

A process is a running activity of code on the data set, and it is the basic unit of resource allocation and scheduling in the system. Thread is an entity, and there is at least one thread in a process, which is the basic unit of CPU scheduling and allocation. Multiple threads in the process share the resources of the process.

Three characteristics of the process:

Dynamic: a process is a running program that dynamically takes up memory, CPU, network and other resources.

Independence: processes are independent of each other and have their own independent memory areas.

Concurrency: if CPU is a single core, only one process is executed in memory at the same time. CPU will time-sharing polling switching to serve each process in turn, because the switching speed is very fast, giving us the impression that these processes are executing at the same time, which is concurrency.

two。 Creation and Operation of Thread

There are three ways we can create threads in a process:

Method 1: inherit the Thread class

1. Define a thread class that inherits the Thread class.

two。 Override the run () method

3. Create a new thread object.

4. Call the thread object's start () method to start the thread.

Public class ThreadDemo {/ / ThreadDemo after startup is treated as a process. The / / main method is executed by the main thread, which is understood that the main method is a main thread public static void main (String [] args) {/ / 3. Create a thread object Thread t = new MyThread (); / / 4. Call the thread object's start () method to start the thread, and finally execute the run () method! T.start (); for (int I = 0; I

< 100 ; i++ ){ System.out.println("main线程输出："+i); } }}// 1.定义一个线程类继承Thread类。class MyThread extends Thread{ // 2.重写run()方法 @Override public void run() { // 线程的执行方法。 for(int i = 0 ; i < 100 ; i++ ){ System.out.println("子线程输出："+i); } }} 优点：编码简单，在run()方法内获取当前线程直接使用this就可以了，无需使用Thread.currentThread()方法。 缺点：线程类已经继承了Thread类无法继承其他类了，功能不能通过继承拓（单继承的局限性）。另外任务与代码没有分离，当多个线程执行一样的任务时需要多份任务代码。 小结： 线程类是继承了Thread的类。 启动线程必须调用start()方法。 多线程是并发抢占CPU执行，所以在执行的过程中会出现并发随机性 方式二：实现Runnable接口的方式。 1.创建一个线程任务类实现Runnable接口。 2.重写run()方法 3.创建一个线程任务对象。 4.把线程任务对象包装成线程对象 5.调用线程对象的start()方法启动线程。 public class ThreadDemo { public static void main(String[] args) { // 3.创建一个线程任务对象(注意：线程任务对象不是线程对象，只是执行线程的任务的) Runnable target = new MyRunnable(); // 4.把线程任务对象包装成线程对象.且可以指定线程名称 // Thread t = new Thread(target); Thread t = new Thread(target,"1号线程"); // 5.调用线程对象的start()方法启动线程 t.start(); Thread t2 = new Thread(target); // 调用线程对象的start()方法启动线程 t2.start(); for(int i = 0 ; i < 10 ; i++ ){ System.out.println(Thread.currentThread().getName()+"==>

"+ I);} / / 1. Create a thread task class to implement the Runnable interface. Class MyRunnable implements Runnable {/ / 2. Override the run () method @ Override public void run () {for (int I = 0; I)

< 10 ; i++ ){ System.out.println(Thread.currentThread().getName()+"==>

"+ I);}

Advantages:

The thread task class simply implements the Runnable interface, can continue to inherit from other classes, and can continue to implement other interfaces (avoiding the limitations of single inheritance). The same thread task object can be wrapped into multiple thread objects, which is suitable for multiple threads to share the same resource. To achieve decoupling operation, thread task code can be shared by multiple threads, thread task code and thread independent.

Method 3: implement the Callable interface

1. Define a thread task class that implements the Callable interface and declares the type of result that the thread executes.

two。 Override the call method of the thread task class, which returns the result of execution directly.

3. Create a thread task object for Callable.

4. Wraps the thread task object of Callable into a FutureTask object.

5. Wraps the FutureTask object as a thread object.

6. Call the thread's start () method to start the thread.

Public class ThreadDemo {public static void main (String [] args) {/ / 3. Create a thread task object for Callable Callable call = new MyCallable (); / / 4. What is the use of packaging the Callable task object as a future task object / /-- public FutureTask (Callable callable) / / what is the future task object? / /-- the future task object is actually a Runnable object: so it can be wrapped as a thread object! / /-- the future task object can get the result of thread execution after the thread has finished execution. FutureTask task = new FutureTask (call) / / 5. Wrap the future task object as a thread object Thread t = new Thread (task); / / 6. Start thread object t.start (); for (int I = 1; I

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.