CFSDN nhấn mạnh vào giá trị tạo ra nguồn mở và chúng tôi cam kết xây dựng nền tảng chia sẻ tài nguyên để mọi nhân viên CNTT có thể tìm thấy thế giới tuyệt vời của bạn tại đây.
Bài viết blog CFSDN này tổng hợp một số cách triển khai/tạo thread trong Java, được tác giả sưu tầm và biên soạn. Nếu bạn quan tâm tới bài viết này thì nhớ like nhé.
Quy trình và chủ đề
Một tiến trình có thể hiểu đơn giản là một chương trình thực thi như .exe. Bạn có thể xem từng tiến trình trong Trình quản lý tác vụ trong Windows. đơn vị lập kế hoạch tài nguyên. Quá trình này chủ yếu chịu trách nhiệm xin tài nguyên từ hệ điều hành. Tuy nhiên, trong một tiến trình, nhiều luồng có thể chia sẻ cùng một tài nguyên bộ nhớ hoặc tệp trong tiến trình đó. Một luồng là một tiến trình hoặc một chương trình cần hoàn thành các nhiệm vụ phụ mà nó phụ thuộc vào. Các nhiệm vụ phụ này có thể được coi là một luồng.
Cách thứ nhất là kế thừa lớp Thread
Có thể thấy từ mã nguồn java rằng lớp Thread về cơ bản thực hiện lớp cá thể của giao diện Runnable và biểu thị một thể hiện của một luồng. Cách duy nhất để bắt đầu một luồng là gọi phương thức start() thông qua lớp Thread. Phương thức start() yêu cầu hoạt động cục bộ. Nếu hệ thống hỗ trợ nó, nó sẽ bắt đầu một luồng mới và thực thi phương thức run().

Kế thừa lớp Thread để triển khai mã luồng như sau.
Vấn đề gì sẽ xảy ra nếu một lớp Thread được tạo và đối tượng gọi trực tiếp phương thức chạy?
gói cn.thread. Biểu mẫu; lớp công khai MyThread mở rộng Thread{ công khai MyThread(String name){ siêu (null, null, name); } int piao = 10; @Ghi đè công khai void run() { while (piao> 0) { System.out.println (Thread.currentThread().getName() + "......" + piao--); } } công khai tĩnh void main (String [] args) { MyThread mt = new MyThread ("x"); mt.run(); }}
kết quả:
Có thể thấy rằng phương thức chạy được thực thi bởi luồng chính chứ không phải phương thức chạy được thực thi bởi luồng người dùng. Lúc này có thể kết luận rằng luồng người dùng chưa được khởi động nên các phương thức trong quá trình chạy sẽ không. được thực thi và luồng sẽ kết thúc sau khi thực hiện phương thức chạy.

Cách thứ hai để tạo thread là triển khai giao diện Runnable
So với việc kế thừa lớp Thread, khả năng mở rộng của giao diện được triển khai đã được cải thiện. Giao diện Runnable cũng phải được gói gọn trong lớp Thread trước khi có thể gọi phương thức start để khởi động luồng.
Thực hiện mã.
gói cn.thread. Biểu mẫu; lớp công khai MyRunnable triển khai Runnable{ int piao = 10; @Ghi đè public void run() { while(piao>0){ System.out.println(Thread.currentThread().getName()+"-----"+piao--); } } public static void main(String[] args) { Runnable r =new MyRunnable(); Luồng t =new Thread(r); t.start(); }}
kết quả.

Phương pháp tạo luồng thứ ba triển khai giao diện Callable
Các phương thức sử dụng của giao diện Callable tương tự như các phương thức của giao diện Runnable. Điểm khác biệt là giao diện Callable có các tác vụ trả về giá trị, trả về kết quả và có thể đưa ra các ngoại lệ. Người triển khai định nghĩa một phương thức gọi là cuộc gọi không có tham số. Giao diện Callable tương tự như Runnable ở chỗ cả hai đều được thiết kế cho các lớp mà phiên bản của chúng có thể được thực thi bởi một luồng khác. Nhưng Runnable không trả về kết quả và không thể đưa ra các ngoại lệ đã kiểm tra.
Thực hiện mã.
Phân tích đoạn mã sau.
Trước hết, giao diện có thể gọi được không thể tạo đối tượng trực tiếp cũng như không thể tạo luồng. Và để thực hiện chức năng của phương thức gọi tương tự như phương thức chạy, phương thức gọi có giá trị trả về và sẽ tính kết quả nếu không tính được kết quả, một ngoại lệ sẽ được đưa ra.
Sau khi thực hiện tác vụ có thể gọi, bạn có thể nhận được một đối tượng trong tương lai. Về cơ bản, Tương lai là một cách để luồng chính theo dõi tiến trình và thu được kết quả của các luồng khác. Ở đây, phương thức Test1() chủ yếu sử dụng nhóm luồng và các phương thức trong tương lai để bắt đầu các luồng triển khai giao diện Có thể gọi và có giá trị trả về. Test2() chủ yếu sử dụng lớp FutureTask để tạo một luồng triển khai giao diện có thể gọi được Futuretask triển khai giao diện trong tương lai.
gói com.openlab.test; nhập java.util.Random; nhập java.util.concurrent.Callable; lớp công khai CallableTest triển khai Callable{ @Ghi đè đối tượng công khai call() ném Ngoại lệ { Trình tạo ngẫu nhiên = new Random(); Số nguyên randomNumber = trình tạo.nextInt(5); Thread.sleep(randomNumber*1000); trả về randomNumber; }}
Mã bài tập toàn diện:
gói cn.thread.thread;nhập java.util.ArrayList;nhập java.util.Date;nhập java.util.List;nhập java.util.Random;nhập java.util.concurrent.*;lớp công khai CallableTest thực hiện Callable< Object> //Không thể tạo chủ đề trực tiếp int taskNum; public CallableTest(int taskNum){ this.taskNum = taskNum } @Override public Object call() ném Ngoại lệ { System.out.println(">>>"+taskNum+"Task Start"); Date dataTemp = new Date(); = dataTemp2.getTime() - dataTemp.getTime(); System.out.println(">>>>"+taskNum+"Tác vụ đã kết thúc"); taskNum+"Task trả về kết quả đang chạy"+time;// Trình tạo ngẫu nhiên = new Random();// Số nguyên ngẫu nhiên = Generator.nextInt(5);// Thread.sleep(randomNumber*1000);// return RandomNumber } / *Phương thức test1 sử dụng phương thức tĩnh newFixedThreadPool(taskSize) của Executor Tạo một nhóm luồng có thể sử dụng lại một tập hợp các luồng cố định, chạy các luồng này trong hàng đợi được chia sẻ không giới hạn và lấy nhóm luồng. Phương thức gửi của ExecutorService gửi một phiên bản có thể gọi được, lấy một đối tượng trong tương lai và cuối cùng lưu trữ đối tượng tương lai trong mảng danh sách. Quá trình tham gia nhóm luồng có nghĩa là luồng đã bắt đầu thực thi, tương đương với quy trình proxy của nhóm luồng. , do đó không cần sử dụng Phương thức bắt đầu sẽ bắt đầu luồng. Cuối cùng, tương lai được in ra. Hãy nhớ tắt nhóm chủ đề! */ static void test1() ném ExecutionException, InterruptedException { System.out.println("Program Start"); Date data1 = new Date(); //Xây dựng đối tượng nhóm luồng ExecutorService pool = Executors.newFixedThreadPool ( taskSize); Danh sách danh sách =new ArrayList(); i=0;i =new ArrayList(); for(int i=0;i>>"+f.get().toString()); } Ngày date2 = Ngày mới(); System.out.println("Chương trình thực thi đã kết thúc-----"+(date2.getTime()-date1.getTime())+"milliseconds"); } public static void main(String[] args) ném ngoại lệ { // CallableTest c = new CallableTest(); // Số nguyên i = (Số nguyên) c.call(); test2();
Kết quả thực hiện.

Cách thứ tư để triển khai các luồng dựa trên nhóm luồng
Trên thực tế, hai phương thức triển khai được đề cập trong phương thức thứ ba, một là nhóm luồng + tương lai và phương thức còn lại là phương thức Futuretask. Chủ đề và kết nối cơ sở dữ liệu là những tài nguyên rất có giá trị. Khi đó, sẽ rất lãng phí tài nguyên nếu tạo ra nó mỗi khi cần và phá hủy nó mỗi khi không cần thiết. Sau đó, chúng ta có thể sử dụng chiến lược bộ nhớ đệm, tức là sử dụng nhóm luồng.
// Tạo một nhóm luồng ExecutorService threadPool = Executors.newFixedThreadPool(10); while(true) { threadPool.execute(new Runnable() { // Gửi nhiều tác vụ luồng và thực thi @Override public void run() { System.out . println(Thread.currentThread().getName() + " đang chạy .."); thử { Thread.sleep(3000 } bắt (InterruptedException e) { e.printStackTrace(); } } });
Tóm tắt
Về lý thuyết, có một số cách để triển khai các luồng. Những cách được đề cập trong bài viết này về cơ bản là một số phương pháp phổ biến để tạo luồng. Hi vọng bài viết này sẽ giúp ích được cho mọi người trong quá trình học đề.
Liên kết gốc: https://blog.csdn.net/cout_s/article/details/119452329.
Cuối cùng, bài viết này về phần tóm tắt một số cách để triển khai/tạo luồng trong Java kết thúc ở đây. Nếu bạn muốn biết thêm về phần tóm tắt về một số cách để triển khai/tạo luồng trong Java, vui lòng tìm kiếm các bài viết về CFSDN hoặc tiếp tục duyệt các bài viết liên quan. Bài viết, tôi hy vọng bạn sẽ ủng hộ blog của tôi trong tương lai! .
Tôi là một lập trình viên xuất sắc, rất giỏi!