Java – Sửa Máy Nhanh

Lập trình đa tiến trình (Multithreading) trong Java

phuongle — Sat, 18 Apr 2020 05:25:26 +0000

1. Đa tiến trình trong ngôn ngữ lập trình Java

Trong Java, Multithreading được gọi là đa luồng, còn Multitasking được gọi là đa tiến trình. Đa luồng và đa tiến trình được sử dụng để tạo ra hệ thống đa nhiệm (multitasking). Một chương trình được gọi là đa luồng khi chương trình đó có 2 luồng trở lên chạy song song với nhau và một luồng (thread) là đơn vị nhỏ nhất của tiến trình (process). Luồng là đơn vị nhỏ nhất trong chương trình có thể thực hiện được một công việc riêng biệt và các luồng này được quản lý bởi máy ảo Java. Một luồng gồm có 4 thành phần chính đó là: định dang, một bộ đếm chương trình, một tập thanh ghi và ngăn xếp. Một ứng dụng Java ngoài luồng chính có thể có các luồng khác thực thi đồng thời. Đa luồng trong Java giúp công việc được hoàn thành một cách nhanh chóng.

Tóm lại, đa luồng trong Java có thể hiểu đơn giản là xử lý nhiều luồng dữ liệu song song với nhau để thực hiện các nhiệm vụ khác nhau cùng một lúc. Tuy nói là cùng một lúc nhưng thời gian để chuyển qua lại giữa các luồng đó vẫn có dộ trễ nhưng rất ngắn (chỉ tính bằng đơn vị nano giây). Để có thể hiểu về đa luồng, tôi có một ví dụ đơn giản như sau: Ta có 2 tiến trình 1 và 2, khi chạy thì tiến trình 1 sẽ được chạy trong một khoảng thời gian nhất định rồi tạm dừng rồi chuyển sang chạy tiến trình 2 và tiến trình 2 cũng chạy trong một khoảng thời gian nhất định và chuyển về tiến trình 1. Quá trình này được thực hiện liên tục đến khi nào 1 trong 2 tiến trình kết thúc. Lưu ý là quá trình chuyển đổi qua lại giữa 2 tiến trình này rất nhanh, thời gian để thực thi 2 tiến trình này cũng rất nhanh nên chúng ta sẽ có cảm giác hai tiến trình 1 và 2 chạy song song với nhau nhưng thực tế nó vẫn có 1 khoảng chênh lệch thời gian nhất định.

2. Các cách tạo luồng trong Java

Java cung cấp cho chúng ta 1 lớp có tên là Thread. Thread là 1 lớp có thể tạo ra 1 lớp chạy đa tiến trình được. Trong Java, chúng ta có hai cách chính để tạo luồng đó là tạo 1 đối tượng của lớp kế thừa lớp Thread và cách thứ hai đó là implements từ 1 Interface có tên là Runnable. Trong phạm vi của bài ngày hôm nay, tôi chỉ nên khái quát về hai cách này, còn về chi tiết sang bài tiếp theo tôi sẽ trình bày kỹ hơn và đưa ra ví dụ cụ thể.

Hai cách trên có những điểm giống nhau nhưng cũng có những điểm khác nhau như sau:

Giống nhau: đều cùng được dùng để tạo luồng.
Khác nhau: Nếu chúng ta tạo luồng bằng cách tạo 1 lớp kế thừa từ lớp Thread thì chúng ta sẽ không thể kế thừa thêm 1 lớp nào khác vì ngôn ngữ lập trình Java không hỗ trợ tính đa kế thừa. Còn nền chúng ta tạo luồng bằng cách implements Interface Runnable thì chúng ta có thể kế thừa một lớp khác ngoài lớp Thread.

3. Lời kết

Trong bài này, tôi đã giới thiệu đến các bạn bài đầu tiên trong chương Luồng dữ liệu này. Cụ thể tôi đã đưa ra các khái niệm thế nào là một chương trình đa tiến trình (hay còn gọi là đa luồng – Multithreading) và khái niệm luồng (thread) là gì và tôi cũng đã đưa ra ví dụ minh họa hai khái niệm luồng và đa luồng. Sau đó, tôi cũng đã nói khái quát về hai cách tạo luồng trong Java đó là tạo luồng thông qua tạo 1 lớp kế thừa từ lớp Thread và thông qua implements Interface Runnable.

Cảm ơn các bạn đã theo dõi bài viết này.

Theo: freetuts.net

The post Lập trình đa tiến trình (Multithreading) trong Java appeared first on Sửa Máy Nhanh.

Tạo và quản lý luồng trong Java

phuongle — Sat, 18 Apr 2020 05:23:46 +0000

1. Tạo luồng bằng cách kế thừa từ lớp Thread

Để tạo luồng bằng cách kế thừa từ lớp Thread, chúng ta phải tạo một lớp kế thừa từ lớp Thread. Như đã nói trong bài trước, Thread là một lớp có thể tạo ra 1 lớp chạy đa tiến trình được. Trong ví dụ dưới đây tôi tạo ra một lớp có tên là MyThread kế thừa từ lớp Thread và dĩ nhiên lúc này lớp MyThread sẽ là một lớp có thể tạo luồng được.

MyThread.java

package vidu;
public class MyThread extends Thread {
}

Sau đó chúng ta sẽ tiến hành ghi đè phương thức run() của lớp Thread. Những gì có trong phương thức run() này sẽ được thực thi khi luồng bắt đầu chạy. Để ghi đè phương thức này, chúng ta vào Source → Override/Implement Methods, sau đó chọn phương thức run() và nhấn OK để kết thúc. Lúc này lớp MyThread sẽ có nội dung như sau:

Java

package vidu;
public class MyThread extends Thread {
    @Override
    public void run() {
        // TODO Auto-generated method stub
        super.run();
    }
}

Trong phương thức run(), để đơn giản tôi sẽ viết 1 vòng lặp for duyệt i từ 0 đến 4. Mỗi lần chạy sẽ hiển thị tên luồng đang chạy thông qua dòng System.out.println(Thread.currentThread().getName()); với kết quả hiển thị không giống nhau. Tức là luồng trong Java sẽ được chạy dưới dạng bất đồng bộ, chúng ta không biết được luồng nào chạy trước và luồng nào chạy sau (phụ thuộc vào hệ điều hành. Hệ điều hành sẽ quyết định tiến trình nào được chạy trước và với mỗi lần chạy thì kết quả sẽ khác nhau, do đó đối với đa luồng thì chúng ta rất khó sửa lỗi).

MyThread.java

package vidu;
public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 5; i++) {
            // Thread.currentThread().getName(): cho chúng ta biết tên luồng đang chạy
            // và tên luồng này có thể thay đổi được.
            System.out.println(Thread.currentThread().getName());
        }
    }
}

TestThread.java

package vidu;
public class TestThread {
    public static void main(String[] args) {
        // Tạo ra luồng myThread0 từ lớp MyThread       
        MyThread myThread0 = new MyThread();
        myThread0.start();  // kích hoạt luồng
        
        // Tạo ra luồng myThread1 từ lớp MyThread       
        MyThread myThread1 = new MyThread();
        myThread1.start();
        
        // Tạo ra luồng myThread2 từ lớp MyThread       
        MyThread myThread2 = new MyThread();
        myThread2.setName("Luồng 2");   // thay đổi tên luồng thành Luồng 2
        myThread2.start();
    }
}

Kết quả sau khi biên dịch chương trình:

Trong lớp TestThread tôi có dòng code myThread2.setName("Luồng 2");, đây là dòng lệnh dùng để thay đổi tên của luồng myThread2 thành “Luồng 2“, mặc định thì tên gọi của mỗi luồng sẽ là Thread-số thứ tự, với số thứ tự của luồng được bắt đầu từ 0.

Lưu ý: Mọi câu lệnh, nhiệm vụ mà chúng ta muốn luồng thực thi thì chúng ta phải khai báo trong phương thức run() (trong ví dụ này thì nhiệm vụ của mỗi luồng là hiển thị tên của luồng đó 5 lần) nhưng nếu chúng ta muốn thực thi luồng đó thì chúng ta phải gọi phương thức start(). Phương thức start() là phương thức dùng để cấp phát tài nguyên cho luồng rồi mới gọi phương thức run() để chạy. Nếu chúng ta không gọi phương thức start() thì những câu lệnh có trong run() sẽ không được chạy.

2. Tạo luồng bằng cách implement Interface Runnable

Để tạo luồng bằng cách implement Interface Runnable, chúng ta phải tạo một lớp implement Interface này. Trong ví dụ dưới đây tôi tạo ra một lớp có tên là DemoThread implement Interface Runnable và dĩ nhiên lúc này lớp DemoThread sẽ là một lớp có thể tạo luồng được.

DemoThread.java

package vidu;
public class DemoThread implements Runnable {
    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}

Tương tự như khi chúng ta tạo luồng bằng cách kế thừa từ lớp Thread thì khi tạo luồng bằng cách implement Interface Runnable thì chúng ta cũng có phương thức run() và những gì có trong phương thức run() này sẽ được thực thi khi luồng bắt đầu chạy, chỉ khác là khi tạo từ lớp Thread thì chúng ta phải tiến hành override lại phương thức này còn đối với tạo từ Runnable thì phương thức run() này đã được tự động override lại.

Trong phương thức run() của lớp DemoThread chúng ta thêm vào đoạn code như sau:

DemoThread.java

package vidu;
public class DemoThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            // Thread.currentThread().getId(): lấy id của luồng đang chạy
            // nó dùng để phân biệt với các luồng khác cùng tiến trình hoặc cùng tập luồng.
            // Đây là thông số mà máy ảo java tự tạo ra khi ta tạo luồng 
            // nên ta không thể sửa đổi cũng như áp đặt thông số này khi tạo luồng. 
            System.out.println(Thread.currentThread().getId() + "\t" + 
                    Thread.currentThread().getName());
        }
    }
}

Main.java

package vidu;
public class Main {
    public static void main(String[] args) {
        DemoThread demoThread0 = new DemoThread();
        Thread thread0 = new Thread(demoThread0);
        thread0.start();
        
        DemoThread demoThread1 = new DemoThread();
        Thread thread1 = new Thread(demoThread1);
        thread1.setName("Luồng 1");
        thread1.start();
        
        DemoThread demoThread2 = new DemoThread();
        Thread thread2 = new Thread(demoThread2);
        thread2.start();
    }
}

Kết quả sau khi biên dịch chương trình:

Chúng ta sẽ sử dụng cách tạo luồng bằng cách implement Interface Runnable khi chúng ta muốn chia sẻ thuộc tính giữa các luồng trong chương trình. Ví dụ dưới đây sé minh họa điều này:

ShareThread.java

package vidu;
public class ShareThread implements Runnable {
    
    private int shareVariable = 0;  // thuộc tính sử dụng chung
    
    public int getShareVariable() {
        return shareVariable;
    }
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("ID:" + Thread.currentThread().getId() + 
                    ", Name: " + Thread.currentThread().getName()
                    + ", shareVariable = " + shareVariable);
            shareVariable += 2;
        }
    }
}

TestShareThread.java

package vidu;
public class TestShareThread {
    public static void main(String[] args) {
        
        ShareThread shareThread = new ShareThread();
        
        Thread thread0 = new Thread(shareThread);
        thread0.setName("Luồng 1");
        thread0.start();
        
        Thread thread1 = new Thread(shareThread);
        thread1.setName("Luồng 2");
        thread1.start();
        
        Thread thread2 = new Thread(shareThread);
        thread2.setName("Luồng 3");
        thread2.start();
        
        System.out.println("Giá trị thuộc tính shareVariable = " + shareThread.getShareVariable());
    }
}

Kết quả sau khi biên dịch chương trình:

3. Lời kết

Trong bài này tôi đã hướng dẫn các bạn các cách tạo luồng trong Java và ví dụ minh họa. Cảm ơn các bạn đã theo dõi bài viết này.

Theo: freetuts.net

The post Tạo và quản lý luồng trong Java appeared first on Sửa Máy Nhanh.

Đồng bộ hóa đa luồng trong Java

phuongle — Sat, 18 Apr 2020 05:17:47 +0000

1. Đồng bộ luồng trong Java

Để các bạn hiểu về đồng bộ luồng trong Java, tôi đưa ra một ví dụ đơn giản cần sử dụng đến đồng bộ như sau: Giả sử một công ty cấp quyền cho 10 nhân viên có thể thực hiện giao dịch rút tiền và chuyển tiền từ tài khoản ngân hàng chung của công ty và số dư của tài khoản này hiện đang la 10.000$. Vào lúc 9h sáng, giám đốc của công ty này đi giao dịch với khách hàng và quyết định rút 2.000$ từ tài khoản. Trong khi hành động rút tiền của vị giám đốc này đang được thực hiện và vẫn chưa kết thúc thì vào lúc này, người kế toán trưởng của công ty bắt đầu thực hiện kiểm tra số dư tài khoản và tiến hành chuyển tiền cho đối tác của công ty với số tiền là 9.000$.

Lúc này, vì giao dịch rút tiền của người giám đốc vẫn chưa kết thúc nên khi người kế toán trưởng kiểm tra số dư thì máy ATM vẫn trả lại số dư là 10.000$ và giao dịch rút 9.000$ của người này vẫn được chấp nhận. Và nếu trong trường hợp này mà không có sự đồng bộ thì cả 2 hành động rút tiền và chuyển tiền đều được thực hiện thành công và vì vậy ngân hàng sẽ mất đi số tiền là 1.000$ → trong trường hợp này bắt buộc cần đến sự đồng bộ hóa giữa các luồng.

Tóm lại, đồng bộ luồng trong Java chính là việc sắp xếp thứ tự các luồng khi truy xuất vào cùng một đối tượng (trong ví dụ trên là số tiền trong tài khoản) sao cho không có sự xung đột dữ liệu. Cơ chế đồng bộ này sẽ khóa hay đồng bộ dữ liệu sử dụng chung để tại một thời điểm chỉ có một luồng được thực thi (rút tiền hoặc chuyển tiền). Chỉ khi nào việc thực thi luồng này kết thúc thì luồng khác mới được thực hiện. Đây chính là cơ chế đồng bộ luồng trong Java.

Để đồng bộ luồng trong Java, chúng ta sẽ sử dụng từ khóa synchronized. Phần dưới đây tôi sẽ trình bày chi tiết.

2. Đồng bộ luồng sử dụng từ khóa synchronized

Để đồng bộ luồng trong Java, chúng ta sẽ sử dụng từ khóa synchronized. Từ khóa này sẽ đứng trước kiểu trả về và đứng sau phạm vi truy cập của phương thức đó.

Để minh họa cách sử dụng từ khóa này, tôi có một ví dụ minh họa bài toán ngân hàng như sau:

Customer.java

package dongboluong;
public class Customer {
    private int taiKhoan = 10000;
        
    public Customer() {
        System.out.println("Tài khoản hiện có = " + taiKhoan);
    }
        
    private synchronized void rutTien (int soTienRut) {
        System.out.println("Giao dịch rút tiền đang được thực hiện với" +
                " số tiền = " + soTienRut + "...");
        
        if(taiKhoan < soTienRut) {
            System.out.println("Số tiền trong tài khoản không đủ!");
            try {
                wait(); // phương thức wail sẽ đưa Thread rơi vào trạng thái sleeping
            } catch (InterruptedException ie) {
                System.out.println(ie.toString());
            }
        }
        
        taiKhoan -= soTienRut;
        System.out.println("Rút tiền thành công. Số tiền hiện có trong tài khoản = " + taiKhoan);
    }
        
    private synchronized void nopTien(int soTienNop) {
        System.out.println("Giao dịch nộp tiền đang được thực hiện với" +
                " số tiền nộp = " + soTienNop + "...");
        taiKhoan += soTienNop;
        System.out.println("Nộp tiền thành công. Số tiền hiện có trong tài khoản = " + taiKhoan);
        notify();
    }
        
    public static void main(String[] args) {
        
        final Customer customer = new Customer();
        
        Thread t1 = new Thread(){
            
            public void run() {
                customer.rutTien(20000);
            }
            
        };
        
        t1.start();
            
        Thread t2 = new Thread(){
            
            public void run() {
                customer.nopTien(30000);
            }
        };
        
        t2.start();
        
    }
    
}

Kết quả sau khi biên dịch chương trình:

Giải thích hoạt động của chương trình trên:

Trong ví dụ trên, tôi giả sử số tiền hiện có trong tài khoản ngân hàng là 10.000$. Trong hàm main(), chúng ta có 2 luồng: luồng t1 sẽ thực hiện việc rút tiền và luồng t2 sẽ thực hiện việc nộp tiền vào tài khoản. Trong Thread t1, khách hàng rút tiền với số tiền là 20.000$ thông qua phương thức rutTien(), lúc này số dư trong tài khoản không đủ nên hành động rút tiền này sẽ được đưa vào trạng thái sleeping thông qua dòng lệnh wait(). Sau đó Thread t2 sẽ được thực thi, lúc này khách hàng sẽ nộp vào tài khoản với số tiền là 40.000$ thông qua phương thức nopTien(). Trong phương thức nopTien() này, khi đã nộp tiền thành công thì dòng lệnh notify() sẽ đánh thức Thread đứng trước nó đang ở trạng thái sleeping vì phương thức wait() bị gọi (ở đây là Thread t1). Lúc này phương thứcrutTien() sẽ kiểm tra số dư tài khoản là 40.000$ > số tiền cần rút là 20.000$ thì hành động rút tiền này sẽ thành công và số dư tài khoản còn lại là 20.000$.

Lưu ý: Trong khi sử dụng phương thức wait(), các bạn thấy có đoạn try...catch bao bọc bên ngoài, thì trong ví dụ này các bạn đừng để ý đến nó mà chỉ cần hiểu đây là điều bắt buộc khi cần sử dụng wait(). Chi tiết về try...catch tôi sẽ trình bày trong chương sau.

3. Lời kết

Trong bài này, tôi đã hướng dẫn các bạn tìm hiểu về cách đồng bộ luồng trong Java bằng cách sử dụng từ khóa synchronized. Cảm ơn các bạn đã theo dõi bài viết này.

Theo: freetuts.net

The post Đồng bộ hóa đa luồng trong Java appeared first on Sửa Máy Nhanh.

Hướng dẫn cách sử dụng sleep() và join()

phuongle — Sat, 18 Apr 2020 05:14:46 +0000

1. sleep()

Phương thức sleep() của lớp Thread được sử dụng để tạm ngưng một Thread đang hoạt động trong một khoảng thời gian nhất định. Để sử dụng phương thức sleep(), Java cung cấp cho chúng ta 2 cú pháp như sau:

Cú pháp

Thread.sleep(long millis);  // tạm dừng Thread với khoảng thời gian dừng tính bằng millisecond
Thread.sleep(long millis, int nanos);   // tạm dừng Thread với khoảng thời gian dừng tính bằng thời gian millis (tính bằng milliseconds) cộng với thời gian nanos (tính bằng nanoseconds và nằm trong khoảng từ 0-999999)

, trong đó millis là khoảng thời gian tính bằng milliseconds và nanos là khoảng thời gian tính bằng nanoseconds.

Lưu ý: Trong khi sử dụng phương thức sleep() này thì trình biên dịch sẽ bắt buộc chúng ta sinh ra đoạn try...catch bao bọc bên ngoài. Tạm thời các bạn đừng để ý đến nó mà chỉ cần hiểu đây là điều bắt buộc khi muốn sử dụng sleep(). Chi tiết về try...catch tôi sẽ trình bày trong chương sau.

Để minh họa cách sử dụng phương thức sleep(), tôi sẽ đưa ra ví dụ minh họa đơn giản như sau:

DemoSleep.java

package phuongthucsleep;
public class DemoSleep extends Thread {
    public void run() {
        super.run();
        for (int i = 1; i <= 5; i++) {
            System.out.println("Đây là Thread thứ " + i);
            System.out.println("Tạm dừng 5000 milliseconds trước khi chuyển sang Thread tiếp theo");
            if (i == 5) {
                System.out.println("Kết thúc!");
            }
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }   // tạm dừng 5000 milliseconds trước khi in ra câu tiếp theo
        }
    }
    
}

Test.java

package phuongthucsleep;
public class Test {
    public static void main(String[] args) {
        DemoSleep t1 = new DemoSleep();
        t1.start();
    }
}

Kết quả sau khi biên dịch chương trình:

2. join()

Phương thức join() được sử dụng để đảm bảo cho quá trình thực thi của Thread đang chạy không bị gián đoạn bởi các Thread khác. Nói một cách khác, nếu một Thread đang trong quá trình được thực thi thì các Thread khác sẽ phải chờ đợi cho đến khi Thread đó thực thi xong. join() được sử dụng khi trong một chương trình Java có nhiều hơn một Thread và chúng ta cần đảm bảo các Thread thực thi và kết thúc đúng theo thứ tự mà chúng đã được khởi tạo.

Để hiểu hơn vai trò của join(), các bạn hãy theo dõi 2 ví dụ sau: Ví dụ thứ nhất là ví dụ không sử dụng join() và ví dụ thứ hai là ví dụ có sử dụng phương thức join():

Ví dụ không sử dụng join()

NoneJoinThread.java

package phuongthucjoin;
public class NoneJoinThread extends Thread {
    public void run() {
        super.run();
        System.out.println(Thread.currentThread().getName() + " đang chạy.");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Kết thúc " + Thread.currentThread().getName());
    }
}

TestNoneJoinThread.java

package phuongthucjoin;
public class TestNoneJoinThread {
    public static void main(String[] args) {
        NoneJoinThread thread1 = new NoneJoinThread();
        thread1.setName("Thread 1");
        NoneJoinThread thread2 = new NoneJoinThread();
        thread2.setName("Thread 2");
        NoneJoinThread thread3 = new NoneJoinThread();
        thread3.setName("Thread 3");
        
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

Kết quả sau khi biên dịch chương trình:

Ví dụ sử dụng join()

JoinThread.java

package phuongthucjoin;
public class JoinThread extends Thread {
    
    public void run() {
        super.run();
        System.out.println(Thread.currentThread().getName() + " đang chạy.");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Kết thúc " + Thread.currentThread().getName());
    }
    
}

TestJoinThread.java

package phuongthucjoin;
public class TestJoinThread {
    public static void main(String[] args) {
        JoinThread thread1 = new JoinThread();
        thread1.setName("Thread 1");
        thread1.start();    // khởi chạy thread 1
        try {
            thread1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        JoinThread thread2 = new JoinThread();
        thread2.setName("Thread 2");
        thread2.start();    // khởi chạy thread2
        try {
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        JoinThread thread3 = new JoinThread();
        thread3.setName("Thread 3");
        thread3.start();    // khởi chạy thread3
        try {
            thread3.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Kết quả sau khi biên dịch chương trình:

Giải thích hoạt động của hai chương trình trên

Trong ví dụ 1 (ví dụ không sử dụng join()) thì chúng ta thấy rằng 3 thread1, thread2, thread3 được khởi chạy theo đúng thứ tự thread1 → thread2 → thread3, nhưng khi kết thúc thì 3 Thread này không theo thứ tự thread1 → thread2 → thread3. Ở mỗi thời điểm chạy chương trình có thể nhận được các kết quả khác nhau.

Còn khi chúng ta sử dụng join() (trong ví dụ 2) thì khi thread1 đang thực thi thì thread2 và thread3 chưa khởi chạy ngay cho dù có lệnh thread2.start() và thread3.start() mà phải đợi cho đến khi thread1 thực thi xong. Tương tự khi thread2 đang chạy thì thread3 vẫn phải đợi cho đến khi thread2 thực thi xong. Do đó mà kết quả in ra màn hình theo đúng thứ tự thread1 → thread2 → thread3 mà chúng đã được khởi chạy.

3. Lời kết

Trong bài này, tôi đã hướng dẫn các bạn tìm hiểu về cách sử dụng sleep() và join().

Cảm ơn các bạn đã theo dõi bài viết này.

Theo: freetuts.net

The post Hướng dẫn cách sử dụng sleep() và join() appeared first on Sửa Máy Nhanh.

Hướng dẫn tạo và sử dụng ThreadPool

phuongle — Sat, 18 Apr 2020 05:02:24 +0000

1. ThreadPool là gì?

Trong Java, ThreadPool được dùng để giới hạn số lượng Thread được chạy bên trong ứng dụng của chúng ta trong cùng một thời điểm. Nếu chúng ta không có sự giới hạn này, mỗi khi có một Thread mới được tạo ra và được cấp phát bộ nhớ bằng từ khóa new thì sẽ có vấn đề về bộ nhớ và hiệu suất, có thể dẫn đến lỗi crash chương trình.

Ví dụ: Khi chúng ta viết chương trình tải các tập tin từ Internet, mỗi tập tin cần 1 Thread để thực hiện quá trình tải, giả sử cần tải 1000 tệp hình ảnh thì chúng ta phải cần tới 1000 Thread hoạt động cùng một thời điểm trong cùng một chương trình. Điều này sẽ dễ dẫn đến lỗi quá tải của chương trình, làm ảnh hưởng đến hiệu suất và chương trình sẽ rất dễ bị crash vì khó kiểm soát.

Vì vậy, để khắc phục hiện tượng này, Java cho phép chúng ta thay vì phải tạo mới Thread cho mỗi nhiệm vụ, quá trình được thực hiện trong cùng một thời điểm thì các nhiệm vụ, quá trình đó có thể được đưa vào trong một ThreadPool để khi trong ThreadPool có bất kỳ Thread nào đang không phải thực hiện một nhiệm vụ nào thì sẽ có nhiệm vụ gán vào một trong số các Thread đó để thực thi. Điều này sẽ giúp khắc phục được sự tắc nghẽn và chương trình sẽ kiểm soát được các luồng thực thi.

Bên trong ThreadPool, các nhiệm vụ sẽ được chèn vào trong một Blocking Queue. Blocking Queue có thể hiểu là nơi chứa các nhiệm vụ mà các Thread sẽ lấy chúng ra và thực thi lần lượt. Mỗi khi có một nhiệm vụ mới được thêm vào Queue và sau đó sẽ chỉ có một Thread đang không phải thực hiện một nhiệm vụ nào vào Queue lấy nhiệm vụ đó ra, còn các Thread còn lại phải chờ đợi cho đến khi Thread đó lấy nhiệm vụ ra thành công.

Ví dụ dưới đây sẽ minh họa cách tạo ThreadPool bằng cách sử dụng ThreadPoolExecutor:

RunPool.java

package vidu;
public class RunPool implements Runnable {
    int id;
    
    @Override
    public void run() {
        System.out.println("Đang xử lý tiến trình " + id);
        
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Đã xử lý tiến trình " + id);
    }
    public RunPool(int id) {
        this.id = id;
    }
}

MyThreadPool.java

package vidu;
 
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
 
public class MyThreadPool {
 
    public static void main(String[] args) {
        ArrayBlockingQueue hangDoi = new ArrayBlockingQueue<>(100);
         
        // khi số tiến trình của chúng ta vượt quá maxSize ở đây là 5
        // ví dụ như đối số thứ nhất = 6
        // thì tất cả những tiến trình mới mà chúng ta tạo ra sẽ được đưa vào hangDoi
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 12, 
            TimeUnit.SECONDS, hangDoi);
        // dùng vòng lặp for để có thể chạy các Thread
        for (int i = 0; i < 10; i++) {
            // trong phương thức execute() thì đối số truyền vào phải là một Runnable
            // đó là lý do mà lớp RunPool phải implements từ interface Runnable
            threadPoolExecutor.execute(new RunPool(i));
        }
    }
 
}

Kết quả sau khi biên dịch chương trình:

Giải thích hoạt động của chương trình trên:

Trong dòng code khởi tạo ThreadPoolExecutor: ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 1, TimeUnit.SECONDS, hangDoi); chúng ta có 5 tham số:

Đối số 1 (corePoolSize) là số lượng Thread tối thiểu trong ThreadPool, ở đây corePoolSize = 5. Khi khởi tạo, số lượng Thread có thể là 0. Khi nhiệm vụ được thêm vào thì Thread mới được tạo ra và kể từ đây, nếu số lượng Thread ít hơn corePoolSize thì những Thread mới sẽ được tạo ra đến khi số Thread bằng giá trị của corePoolSize.
Đối số 2 (maximumPoolSize) là số lượng tối đa các Thread trong ThreadPool.
Đối số 3 (keepAliveTime): khi số Thread lớn hơn corePoolSize thì keepAliveTime là thời gian tối đa mà 1 Thread “nhàn rỗi” chờ nhiệm vụ. Khi hết thời gian chờ mà Thread đó chưa có nhiệm vụ thì nó sẽ bị hủy.
Đối số 4 (unit) là đơn vị thời gian của keepAliveTime. Trong ví dụ này thì unit của tôi là TimeUnit.SECONDS.
Đối số 5 (workQueue) là hàng đợi dùng để chứa các nhiệm vụ mà các Thread sẽ lấy chúng ra và thực thi lần lượt, ở đây tôi dùng ArrayBlockingQueue.

2. ExecutorService

Kể từ Java 5 trở đi, ThreadPool đã được xây dựng sẵn trong gói java.util.concurrent, vì vậy chúng ta không cần phải tạo một ThreadPool mà thay vào đó chúng ta sẽ sử dụng các lớp có sẵn của gói này. Java cung cấp cho chúng ta lớp Executor, interface của lớp Executor là ExecutorService.

Ta có thể tạo ThreadPool thông qua Interface ExecutorService, các nhiệm vụ sẽ được đưa vào ThreadPool và được xử lý bằng một trong những phương thức có sẵn mà Executor cung cấp như sau:

newSingleThreadExecutor(): Trong ThreadPool chỉ có 1 Thread và các nhiêm vụ sẽ được xử lý một cách tuần tự.
newCachedThreadPool(): Trong ThreadPool sẽ có nhiều Thread và các nhiệm vụ sẽ được xử lý một cách song song. Các Thread cũ sau khi xử lý xong sẽ được sử dụng lại cho nhiệm vụ mới. Mặc định nếu một Thread không được sử dụng trong vòng 60 giây thì Thread đó sẽ bị tắt.
newFixedThreadPool(): Trong ThreadPool sẽ được cố định các Thread. Nếu một nhiệm vụ mới được đưa vào mà các Thread đều đang “bận rộn” thì nhiệm vụ đó sẽ được gửi vào Blocking Queue và sau đó nếu có một Thread đã thực thi xong nhiệm vụ của nó thì nhiệm vụ đang ở trong Queue đó sẽ được push ra khỏi Queue và được Thread đó xử lý tiếp.
newScheduledThreadPool(): tương tự như newCachedThreadPool() nhưng sẽ có thời gian delay giữa các Thread.
newSingleThreadScheduledExecutor(): tương tự như newSingleThreadExecutor() nhưng sẽ có khoảng thời gian delay giữa các Thread.

Interface ExecutorService đại diện cho cơ chế thực thi bất đồng bộ có khả năng thực thi các nhiệm vụ trong background (nền). ExecutorService tương tự như một ThreadPool và trong thực tế, việc triển khai ExecutorService là một triển khai ThreadPool.

Sau đây tôi sẽ đưa ra một ví dụ minh họa cách sử dụng ExecutorService:

RunPool.java

package vidu;
public class RunPool implements Runnable {
    int id;
    
    @Override
    public void run() {
        System.out.println("Đang xử lý tiến trình " + id);
        
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Đã xử lý tiến trình " + id);
    }
    public RunPool(int id) {
        this.id = id;
    }
}

MyThreadPool.java

package vidu;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
public class MyThreadPool {
 
    public static void main(String[] args) {
         
        ExecutorService pool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            pool.submit(new RunPool(i));    // chay ThreadPool, đối số là 1 Runnable
        }
        
        try {
            // thời gian sống của mỗi Thread là 1 ngày (nếu nó chưa thực thi xong)
            pool.awaitTermination(1, TimeUnit.DAYS);    
        } catch (InterruptedException e) {
            e.printStackTrace();
        }       
        
        pool.shutdown();    // tắt ThreadPool
    }
 
}

Kết quả sau khi biên dịch chương trình:

Lưu ý: Bạn nên shutdown một ThreadPool bằng cách gọi phương thức shutdown() bởi vì ta không thể chắc chắn được rằng máy ảo Java có thể tự động làm điều đó.

3. Lời kết

Trong bài này, tôi đã hướng dẫn các bạn tìm hiểu về cách tạo và sử dụng ThreadPool .

Theo: freetuts.net

The post Hướng dẫn tạo và sử dụng ThreadPool appeared first on Sửa Máy Nhanh.

Sử dụng CountDownLatch trong Java

phuongle — Sat, 18 Apr 2020 04:58:32 +0000

1. CountDownLatch

CountDownLatch là một lớp trong Java chuyên dùng để đếm. Tại sao Java lại tạo ra một lớp riêng để đếm trong khi chúng ta hoàn toàn có thể thực hiện việc đếm bằng cách khác? Bởi vì trong lập trình đa luồng, việc đếm này sẽ rất khó và phức tạp, thường khi muốn đếm thì chúng ta phải sử dụng đến đồng bộ phương thức nếu không việc đếm sẽ không chính xác, vì lúc này trong hệ thống các luồng đang được xử lý song song và các biến sẽ được sử dụng một cách không tuần tự lúc đó kết quả đếm sẽ không chính xác và không như chúng ta mong muốn.

Để hiểu rõ hơn các bạn theo dõi ví dụ sau:

DemoNonCountDownLatch.java

package countdownlatch;
public class DemoNonCountDownLatch {
    
    private int count = 2000;
 
    public void dem() {
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count--;
                }
            }
        });
         
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count--;
                }
            }
        });
         
        thread1.start();
        thread2.start();
 
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException ignored) {
        }   
        
        System.out.println("Count = " + count);
    }
    
    public static void main(String[] args) {
        DemoNonCountDownLatch demoNonCountDownLatch = new DemoNonCountDownLatch();
        demoNonCountDownLatch.dem();
    }
}

Kết quả sau khi biên dịch chương trình:

Với đoạn code trên thì khi thực thi chương trình, kết quả mà chúng ta mong muốn là giá trị của biến count sẽ bằng 0, nhưng vì thread1 và thread2 lúc này là 2 luồng chạy song song nên kết quả biến count sau mỗi lần biên dịch sẽ khác nhau. Vì biến count được cả hai thread1 và thread2 cùng đồng thời tác động và thay đổi giá trị nên sẽ xảy ra trường hợp thread1 chưa xử lý xong (giảm count đi 1) thì thread2 đã thực hiện tác động tới biến count này nên giá trị của count sẽ thay đổi và không theo ý muốn của chúng ta.

Vì vậy, để giải quyết trường hợp này, chúng ta có thể sử dụng từ khóa synchronized để đảm bảo rằng việc giảm biến count đi 1 sẽ được xử lý một cách tuần tự, tức là tại 1 thời điểm chỉ có duy nhất một Thread được thao tác với biến count:

UseSynchronizedMethod.java

package countdownlatch;
import java.util.concurrent.CountDownLatch;
public class DemoCountDownLatch {
    
    public CountDownLatch count = new CountDownLatch(2000);
    public void doWork() {
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count.countDown();  // giảm giá trị của biến count
                }
            }
        });
         
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count.countDown();
                }
            }
        });
         
        thread1.start();
        thread2.start();
 
        try {
            count.await();
        } catch (InterruptedException ignored) {
        
        }
        System.out.println("Count = " + count.getCount());
    }
    
    public static void main(String[] args) {
        DemoCountDownLatch demo = new DemoCountDownLatch();
        demo.doWork();
    }
    
}

Kết quả sau khi biên dịch chương trình:

Trong đoạn code trên, từ khóa synchronized ở phương thức giamCount() đã bảo đảm rằng tại một thời điểm chỉ có duy nhất 1 Thread được gọi vào hàm để xử lý.

Ngoài ra, như nội dung chính của phần này đó là chúng ta có thể dùng CountDownLatch để giải quyết vấn đề này:

DemoCountDownLatch.java

package countdownlatch;
import java.util.concurrent.CountDownLatch;
public class DemoCountDownLatch {
    
    public CountDownLatch count = new CountDownLatch(2000);
    public void doWork() {
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count.countDown();  // giảm giá trị của biến count đi 1
                }
            }
        });
         
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    count.countDown();
                }
            }
        });
         
        thread1.start();
        thread2.start();
 
        try {
            count.await();
        } catch (InterruptedException ignored) {
        
        }
        System.out.println("Count = " + count.getCount());
    }
    
    public static void main(String[] args) {
        DemoCountDownLatch demo = new DemoCountDownLatch();
        demo.doWork();
    }
    
}

Kết quả sau khi biên dịch chương trình:

Giải thích hoạt động của chương trình trên:

Đoạn code public CountDownLatch count = new CountDownLatch(2000); sẽ khởi tạo một đối tượng CountDownLatch có tên là count với giá trị là 2000. Còn để giảm dần giá trị của count thì lớp CountDownLatch cung cấp cho chúng ta phương thức countDown(): count.countDown();. Ngoài ra, chúng ta còn thấy dòng code count.await();, phương thức await() sẽ đợt tất cả các tiến trình xử lý của CountDownLatch hoàn thành (tương tự như phương thức join()trong Thread).

2. Lời kết

Trong bài này, tôi đã hướng dẫn các bạn tìm hiểu về lớp CountDownLatch trong Java. Cảm ơn các bạn đã theo dõi bài viết này.

Theo: freetuts.net

The post Sử dụng CountDownLatch trong Java appeared first on Sửa Máy Nhanh.

Tổng quan về Exception trong Java

phuongle — Sat, 18 Apr 2020 04:55:54 +0000

1. Exception (Ngoại lệ) là gì?

Exception là một sự kiện chỉ xảy ra trong quá trình chương trình Java thực thi một câu lệnh nào đó và thông thường nó sẽ phá vỡ luồng làm việc của chương trình, tức là chương trình đang chạy sẽ lập tức ngừng lại và xuất hiện thông báo lỗi. Đó chính là Exception (ngoại lệ).

Ví dụ dễ hiểu nhất về Exception đó chính là khi chúng ta tiến hành thực hiện phép chia một số nguyên dương cho số 0 thì khi biên dịch chương trình sẽ làm phát sinh lỗi và đó được coi là ngoại lệ.

2. Các loại Exception trong Java

Trong Java có 2 loại Exception là Checked Exception và Unchecked Exception.

Checked Exception là các Exception xảy ra tại thời điểm Compile time (là thời điểm chương trình đang được biên dịch). Những Exception này thường liên quan đến lỗi cú pháp (syntax) và bắt buộc chúng ta phải “bắt” (catch) nó.
Unchecked Exception: là các Exception xảy ra tại thời điểm Runtime (là thời điểm chương trình đang chạy). Những Exception này thường liên quan đến lỗi logic và không bắt buộc chúng ta phải “bắt” (catch) nó.

Sau đây tôi sẽ đưa ra 2 ví dụ minh họa Checked Exception và Unchecked Exception:

CheckedException.java

package vidu;
public class CheckedException {
    public static void main(String[] args) {
        System.out.println(ABC);
    }
    
}

Lúc này, ngay tại dòng code System.out.println(ABC); sẽ bị lỗi. Lý do là vì ví dụ này mục đích là để hiển thị một chuỗi, mà đã hiển thị chuỗi thì bắt buộc chuỗi đó phải nằm trong cặp dấu ” “. Đây chính là Checked Exception, lúc này nếu chúng ta tiến hành chạy chương trình thì sẽ có thông báo lỗi hiển thị trong cửa sổ Console. Kết quả biên dịch chương trình như sau:

UncheckedException.java

package vidu;
public class UncheckedException {
    public static void main(String[] args) {
        int a = 5, b = 0;
        System.out.println(a/b);
    }
}

Lúc này, chương trình sẽ không báo lỗi gì trong đoạn code của chúng ta nhưng khi biên dịch thì sẽ có thông báo lỗi “/ by zero” (lỗi chia cho 0) trong màn hình Console. Đây chính là Unchecked Exception. Kết quả sau khi biên dịch chương trình:

3. Các cách xử lý Exception

Trong Java, để xử lý ngoại lệ chúng ta sẽ có các cách được liệt kê dưới đây và chi tiết về các cách này tôi sẽ giới thiệu trong các bài sau.

Sử dụng khối try...catch để xử lý.
Sử dụng multicatch để bắt nhiều ngoại lệ.
Sử dụng khối try...catch...finally.
Sử dụng try with resource.
Sử dụng Nested try (lồng một khối try trong một try khác).
Sử dụng từ khóa throw và throws.

4. Lời kết

Trong bài này, tôi đã giới thiệu đến các bạn Tổng quan về Exception trong Java. Cảm ơn các bạn đã theo dõi bài viết này.

Theo: freetuts.net

The post Tổng quan về Exception trong Java appeared first on Sửa Máy Nhanh.

Try Catch trong Java – Xử lý Exception

phuongle — Sat, 18 Apr 2020 04:49:26 +0000

Khối lệnh try (try block) trong Java

Try block chứa tập hợp các câu lệnh có thể xảy ra ngoại lệ. Try block luôn được theo sau bởi catch block để xử lý ngoại lệ của nó. Try block phải được theo sau bởi catch block hoặc finally block hoặc cả hai.

Cú pháp của try block

try{
   // Các câu lệnh có thể tạo ra exception
}

Trong quá trình code, nếu bạn nghĩ rằng có một số câu lệnh trong chương trình có thể tạo ra exception, hãy đặt chúng trong catch block và xử lý ngoại lệ đó.

Khối lệnh catch(catch block)

Catch block là nơi bạn xử lý các exception, nó phải đi kèm với try block. Một try block có thể có một hoặc nhiều catch block. Ta có thể bắt các exception khác nhau trong các catch block khác nhau. Khi một exception được tạo ra trong try block, đoạn code trong catch block tương ứng xử lý exception đó sẽ được thực thi. Ví dụ: nếu một exception số học xảy ra trong try block thì các câu lệnh được bao trong catch block dùng để xử lý exception đó sẽ được thực thi.

Cú pháp try catch trong java

try
{
     // Các câu lệnh có thể tạo ra exception
}
catch (exception(type) e(object))‏
{
     // Code xử lí exception e
}

Ví dụ về try catch

Nếu một exception xảy ra trong try block thì chương trình sẽ thực thi các câu lệnh trong catch block tương ứng. Một try block có thể có nhiều catch block được liên kết với nó, bạn nên sắp xếp các catch block hợp lí sao cho catch block xử lý exception chung ở cuối cùng (xem trong ví dụ bên dưới).

Một exception chung có thể xử lý tất cả các ngoại lệ nhưng bạn nên đặt ở cuối, nếu bạn đặt nó ở trước tất cả các catch block khác thì nó sẽ hiển thị một thông báo chung cho tất cả trường hợp. Chắc chắn bạn sẽ không muốn điều đó xảy ra đâu.

class Example1 {
   public static void main(String args[]) {
      int num1, num2;
      try {
         /* Ta nghi ngờ rằng khối lệnh này sẽ throw ra
          * exception vì vậy ta sẽ xử lý nó bằng cách đặt các câu lệnh này
          * bên trong try block và xử lý exception trong catch block
          */
         num1 = 0;
         num2 = 62 / num1;
         System.out.println(num2);
         System.out.println("Kết thúc try block.");
      }
      catch (ArithmeticException e) { 
         /* Catch block này sẽ chỉ thực hiện nếu có ngoại lệ số học
          * xảy ra trong try block
          */
         System.out.println(" Lỗi: Số bị chia không thể là số 0");
      }
      catch (Exception e) {
         /* Đây là một exception chung, nó có thể xử lý
          * tất cả các exception.Catch block này sẽ thực thi nếu ngoại lệ không
          * được xử lý bởi catch block bên trên
          */
         System.out.println("Lỗi: một ngoại lệ đã xảy ra");
      }
      System.out.println("Ra khỏi try catch block.");
   }
}

Output:

Lỗi: Số bị chia không thể là số 0
Ra khỏi try catch block.

Nhiều catch block trong Java

Sau đây là vài quy tắc cần lưu ý khi sử dụng try catch:

Quy tắc 1. Một try block có thể nhiều catch block.

Quy tắc 2. Một catch block xử lí exception chung có thể xử lý tất cả các exception, cho dù đó là ArrayIndexOutOfBoundExceptionhay ArithaturesExceptionhay NullPulumExceptionhay bất kỳ loại exception nào.

catch(Exception e){
  // catch block này có thể xử lí tất cả các exception
}

Nếu bạn đang thắc mắc tại sao chúng ta cần phải xử lí các exception khác trong khi có thể code gọn hơn bằng cách catch exception chung cho tất cả trường hợp. Thì bạn phải nhớ rằng việc catch một exception chung sẽ chỉ hiển thị cùng một thông báo cho tất cả các ngoại lệ, và người dùng hoặc có thể là bạn sẽ không biết được exception nào đang xảy ra. Đó là lý do bạn nên đặt catch block xử lí exception chung ở cuối.

Quy tắc 3. Nếu không có exception xảy ra trong try block thì catch block hoàn toàn bị bỏ qua.

Quy tắc 4. Các catch block tương ứng thực thi cho exception cụ thể đó:
catch (ArithaturesException e) dùng để xử lí ngoại lệ ArithaturesException
catch (NullPulumException e) dùng để xử lí ngoại lệ NullPulumException

Quy tắc 5. Bạn cũng có thể throw exception, đây là phần nâng cao, tôi sẽ đề cập đến phần này trong một bài viết khác.

Ví dụ về nhiều catch block

class Example2{
   public static void main(String args[]){
     try{
         int a[]=new int[7];
         a[4]=30/0;
         System.out.println("Câu lệnh in đầu tiên trong try block");
     }
     catch(ArithmeticException e){
        System.out.println("Cảnh báo: ngoại lệ ArithmeticException");
     }
     catch(ArrayIndexOutOfBoundsException e){
        System.out.println("Cảnh báo: ngoại lệ ArrayIndexOutOfBoundsException");
     }
     catch(Exception e){
        System.out.println("Cảnh báo: ngoại lệ khác");
     }
   System.out.println("Ra khỏi try-catch block...");
  }
}

Output:

Cảnh báo: ngoại lệ ArithmeticException
Ra khỏi try-catch block...

Trong ví dụ trên có nhiều catch block và các catch block này thực hiện tuần tự khi có exception xảy ra trong try block. Điều đó có nghĩa là nếu bạn đặt catch block cuối cùngcatch(Exception e) ở vị trí đầu tiên, ngay sau try block thì trong trường hợp có bất kỳ exception nào, khối này sẽ thực thi vì nó có thể xử lý tất cả các exception. Catch block này nên được đặt ở cuối cùng để tránh những tình huống như vậy.

Finally block

Trong bài này chúng ta sẽ không đào sâu về finally block, bạn chỉ cần biết rằng khối này sẽ thực thi cho dù có exception xảy ra hay không. Hãy đặt các câu lệnh cần phải được thực thi mà không phụ thuộc vào việc exception có xảy ra hay không tại finally block.

Theo: freetuts.net

The post Try Catch trong Java – Xử lý Exception appeared first on Sửa Máy Nhanh.

Finally trong Java – Xử lí exception

phuongle — Sat, 18 Apr 2020 04:45:35 +0000

Trong bài này, chúng ta sẽ tìm hiểu về finally block, nó được sử dụng cùng với try-catch. Các câu lệnh có trong finally block sẽ luôn thực thi bất kể exception có xảy ra trong try catch hay không, chẳng hạn như việc ngắt kết nối, ngắt luồng,..v..v.. là những việc cần phải làm bất kể có exception xảy ra hay không.

Cú pháp của finally block

try {
// Các câu lệnh có thể tạo ra exception
}
catch {
// Xử lí exception
}
finally {
// Các câu lệnh sẽ thực thi bất kể có exception xảy ra hay không
}

Ví dụ về finally block

Bạn có thể thấy rằng exception xảy ra trong try block đã được xử lý trong catch block, sau đó đến finally block được thực thi.

class Example
{
public static void main(String args[]) {
try{  
int num=121/0;  
System.out.println(num);  
}  
catch(ArithmeticException e){
System.out.println("Lỗi: không thể chia cho số 0");
}  
/* Finally block sẽ luôn được thực thi
* dù có exception hay không
*/
finally{
System.out.println("Đây là finally block");
}  
System.out.println("Ra khỏi try-catch-finally");  
}   
}

Output:

Lỗi: không thể chia cho số 0
Đây là finally block
Ra khỏi try-catch-finally

Vài điều quan trọng về finally block

Finally block phải được dùng chung với với try block, bạn không thể sử dụng nó mà không có try block. Bạn nên đặt các câu lệnh phải được thực thi bất chấp có exception hay không bên trong finally block.
Finally block có thể có hoặc không, try-catch block là đủ để xử lý exception, tuy nhiên nếu bạn đặt finally block thì nó sẽ luôn chạy sau khi thực hiện try block.
Trong trường hợp bình thường khi không có exception trong try block thì finally block được thực thi sau try block. Tuy nhiên, nếu một exception xảy ra thì catch block được thực thi trước finally block.
Một exception trong finally block có thể chạy như bất kỳ exception nào khác bên ngoài nó.
Các câu lệnh có trong finally block thực thi ngay cả khi try block chứa các câu lệnh chuyển điều khiển như return, break hoặc continue.

Hãy xem một ví dụ để xem finally hoạt động như thế nào khi câu lệnh return xuất hiện trong try block:

Một ví dụ chứa cả finally block và return trong try block

Bạn có thể thấy rằng mặc dù chúng ta có câu lệnh return trong try block, các câu lệnh trong finally block vẫn chạy.

class JavaFinally
{
public static void main(String args[])
{
System.out.println(JavaFinally.myMethod());  
}
public static int myMethod()
{
try {
return 112;
}
finally {
System.out.println("Đây là finally block");
System.out.println("Finally block vẫn chạy mặc dù lệnh return trong try block đã được thực thi trước");
}
}
}

Output:

Đây là finally block
Finally block vẫn chạy mặc dù lệnh return trong try block đã được thực thi trước

Các trường hợp khi finally block không được thực hiện.

Các trường hợp ngăn code thực thi trong một finally block:

Một thread bị ngừng.
Sử dụng phương thức System.exit().
Do một exception phát sinh trong finally block.

Finally và Close()

Câu lệnh close() được sử dụng để đóng tất cả các tiến trình (thread) được mở trong một chương trình. Nó có thể được đặt trong finally block nếu bạn muốn đóng một thread nào đó. Vì finally block thực thi ngay cả khi exception xảy ra, do đó bạn có thể chắc chắn rằng tất cả các input và output stream được đóng đúng cách bất kể exception có xảy ra hay không.

Ví dụ:

....
try{ 
OutputStream osf = new FileOutputStream( "filename" );
OutputStream osb = new BufferedOutputStream(opf);
ObjectOutput op = new ObjectOutputStream(osb);
try{
output.writeObject(writableObject);
}
finally{
op.close();
}
}
catch(IOException e1){
System.out.println(e1);
}
...

Finally block không sử dụng catch

Có thể dùng try-finally block mà không có catch block.

...
InputStream input = null;
try {
    input = new FileInputStream("inputfile.txt");
} 
finally {
    if (input != null) {
       try {
         in.close();
       }catch (IOException exp) {
           System.out.println(exp);
        }
    }
}
...

Finally block và System.exit()

Câu lệnh System.exit() hoạt động khác với câu lệnh return. Không giống như return, bất cứ khi nào System.exit() được gọi trong try block thì finally block sẽ không thực hiện. Đây là một ví dụ để chứng minh:

....
try {
//try block
System.out.println("Bên trong try block");
System.exit(0)
}
catch (Exception exp) {
System.out.println(exp);
}
finally {
System.out.println("Bên trong finally block");
}
....

Output:

Bên trong try block

Trong ví dụ trên nếu System.exit(0) được gọi mà không có exception nào thì finally sẽ không được thực thi. Tuy nhiên, nếu có bất kỳ exception nào xảy ra trong khi gọi System.exit(0) thì finally block sẽ được thực thi.

try-catch-finally block

Try block nên được liên kết với catch block hoặc finally block.
Vì catch block thực hiện xử lý exception và finally block thực hiện việc dọn dẹp, nên cách tốt nhất là sử dụng cả hai.

Cú pháp:

try {
// Các câu lệnh có thể tạo ra exception
}
catch (…)‏ {
// Xử lí exception
}
finally {
// Các câu lệnh được thực thi bất kể có exception hay không
}

Ví dụ về try-catch-finally block

Ví dụ 1: Ví dụ minh họa hoạt động của finally block khi không có exception xảy ra.

class Example1{
public static void main(String args[]){
try{
System.out.println("Câu lệnh đầu tiên của try block");
int num=45/3;
System.out.println(num);
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("ArrayIndexOutOfBoundsException");
}
finally{
System.out.println("Finally block");
}
System.out.println("Ra ngoài try-catch-finally block");
}
}

Output:

Câu lệnh đầu tiên của try block
15
Finally block
Ra ngoài try-catch-finally block

Ví dụ 2: Ví dụ minh họa hoạt động của finally block khi có exception xảy ra trong try block nhưng không được xử lý trong catch block.

class Example2{
public static void main(String args[]){
try{
System.out.println("Câu lệnh đầu tiên của try block");
int num=45/0;
System.out.println(num);
}
catch(ArrayIndexOutOfBoundsException e){
System.out.println("ArrayIndexOutOfBoundsException");
}
finally{
System.out.println("Finally block");
}
System.out.println("Ra ngoài try-catch-finally block");
}
}

Output:

Câu lệnh đầu tiên của try block
Finally block
Exception in thread "main" java.lang.ArithmeticException: / by zero
at beginnersbook.com.Example2.main(Details.java:6)

Bạn có thể thấy rằng thông báo exception do hệ thống tạo ra được hiển thị nhưng trước đó finally đã thực hiện thành công.

Ví dụ 3: Khi xảy ra exception trong try block và cách xử lí trong catch block.

class Example3{
public static void main(String args[]){
try{
System.out.println("Câu lệnh đầu tiên của try block");
int num=45/0;
System.out.println(num);
}
catch(ArithmeticException e){
System.out.println("ArithmeticException");
}
finally{
System.out.println("Finally block");
}
System.out.println("Ra ngoài try-catch-finally block");
}
}

Output:

Câu lệnh đầu tiên của try block
ArithmeticException
Finally block
Ra ngoài try-catch-finally block

Theo: freetuts.net

The post Finally trong Java – Xử lí exception appeared first on Sửa Máy Nhanh.

Throw exception trong Java

phuongle — Sat, 18 Apr 2020 04:33:31 +0000

Trong bài này chúng ta sẽ tìm hiểu cách sử dụng từ khóa throw trong Java.

Java đã định nghĩa sẵn các class exception như ArithaturesException, NullPulumException, hay ArrayIndexOutOfBound,..v..v.. Những exception này được dùng để catch các trường hợp khác nhau.

Ví dụ: khi chúng ta chia một số cho 0, exception ArithaturesExceptionsẽ được ném ra (throw), hoặc là khi chúng ta cố gắng truy cập phần tử của mảng mà phần tử đó không nằm trong giới hạn của nó thì chúng ta sẽ nhận được exception ArrayIndexOutOfBoundException.

Chúng ta có thể ném một exception bằng cách sử dụng từ khóa throw.

Ví dụ: chúng ta có thể throw exception ArithaturesExceptionkhi chúng ta chia số cho 5 hoặc bất kỳ số nào khác, bạn chỉ cần đặt điều kiện và throw bất cứ exception nào bạn thích.

1. Cú pháp của từ khóa throw trong Java

Bạn có thể ném một throw bằng cách sử dụng cú pháp dưới đây.

throw new exception_class("error message");

Ví dụ:

throw new ArithmeticException("dividing a number by 5 is not allowed in this program");

2. Ví dụ về từ khóa throw trong Java

Giả sử chúng ta đang cần chọn các học sinh có tuổi trên 12 hoặc cân nặng trên 40 để tham dự giải hội thao, nếu bất kỳ điều kiện nào kể trên không được đáp ứng thì từ chối học sinh đó, lúc đó ta sẽ throw ArithmeticExceptionvới cảnh báo “Student is not eligible for registration”.

Chúng ta kiểm tra bằng method checkEligibilty(int stuage, int stuweight) bên dưới.

/* In this program we are checking the Student age
 * if the student age<12 and weight <40 then our program 
 * should return that the student is not eligible for registration.
 */
public class ThrowExample {
   static void checkEligibilty(int stuage, int stuweight){ 
      if(stuage<12 && stuweight<40) {
         throw new ArithmeticException("Student is not eligible for registration"); 
      }
      else {
         System.out.println("Student Entry is Valid!!"); 
      }
   } 
   public static void main(String args[]){ 
     System.out.println("Welcome to the Registration process!!");
     checkEligibilty(10, 39); 
     System.out.println("Have a nice day.."); 
 } 
}

Output:

Welcome to the Registration process!!Exception in thread "main"
java.lang.ArithmeticException: Student is not eligible for registration
at beginnersbook.com.ThrowExample.checkEligibilty(ThrowExample.java:9)
at beginnersbook.com.ThrowExample.main(ThrowExample.java:18)

Trong ví dụ trên, chúng ta đã tự throw ra một unchecked exception, loại exception này được bỏ qua trong quá trình biên dịch, không bắt buộc ta phải xử lí nó. Bạn cũng có thể throw một user-defined exception bằng cách tương tự như ví dụ trên.

Trong trường hợp bạn chưa biết user-defined exception là gì, xin mời bạn đọc qua bài viết tiếp theo để hiểu rõ hơn.

Theo: freetuts.net

The post Throw exception trong Java appeared first on Sửa Máy Nhanh.

Các ví dụ về exception trong Java

phuongle — Sat, 18 Apr 2020 04:21:54 +0000

Chúng ta đã được học xong toàn bộ kiến thức về cách xử lý ngoại lệ Exception trong Java, vậy thì bài này mình sẽ đưa ra một vài ví dụ về các trường hợp gặp Exception phổ biến nhất khi làm việc với Java.

Ví dụ 1: Ngoại lệ số học (ArithmeticException)

Class: Java.lang.ArithmeticException

Đây là một class có sẵn trong gói java.lang. Exception này xảy ra khi ta chia một số nguyên với số 0.

class Example1
{
   public static void main(String args[])
   {
      try{
         int num1=30, num2=0;
         int output=num1/num2;
         System.out.println ("Result: "+output);
      }
      catch(ArithmeticException e){
         System.out.println ("You Shouldn't divide a number by zero");
      }
   }
}

Output:

You Shouldn't divide a number by zero

Trong ví dụ trên, chúng ta đã chia một số nguyên cho số 0 vì vậy trình biên dịch sẽ throw ra ArithaturesException.

Ví dụ 2: Ngoại lệ ArrayIndexOutOfBound

Class: Java.lang.ArrayIndexOutOfBoundsException

Ngoại lệ này xảy ra khi bạn cố gắng truy cập đến bên ngoài kích thước của một mảng. Ví dụ: Nếu mảng chỉ có 5 phần tử và bạn cố gắng hiển thị phần tử thứ 7 thì nó sẽ ném ngoại lệ này.

class ExceptionDemo2
{
   public static void main(String args[])
   {
      try{
        int a[]=new int[10];
        //Array has only 10 elements
        a[11] = 9;
      }
      catch(ArrayIndexOutOfBoundsException e){
         System.out.println ("ArrayIndexOutOfBounds");
      }
   }
}

Output:

ArrayIndexOutOfBounds

Trong ví dụ trên, mảng được khởi tạo có 10 phần tử, index từ 0 đến 9. Vì chúng ta đang cố gắng truy cập phần tử có index là 11, vượt ra ngoài kích thước của mảng nên chương trình ném ra ngoại lệ này.

Ví dụ 3: NumberFormatException

Class: Java.lang.NumberFormatException

Ngoại lệ này xảy ra khi một string bị ép kiểu sang bất cứ kiểu dữ liệu số học nào.
Ví dụ: câu lệnh int num = Integer.parseInt (“XYZ”); sẽ throw NumberFormatExceptionvì chuỗi “XYZ” không thể được ép kiểu thành int.

class ExceptionDemo3
{
   public static void main(String args[])
   {
      try{
     int num=Integer.parseInt ("XYZ") ;
     System.out.println(num);
      }catch(NumberFormatException e){
      System.out.println("Number format exception occurred");
       }
   }
}

Output:

Number format exception occurred

Ví dụ 4: Ngoại lệ StringIndexOutOfBound

Class: Java.lang.NullPointer Exception
NullPointerExceptionlà lỗi ngoại lệ xảy ra khi bạn tham chiếu tới Object nhưng nó lại không có vị trí nào trên bộ nhớ (null). Gọi một method tham chiếu null hoặc cố gắng truy cập một trường tham chiếu null là một trong những nguyên nhân phổ biến gây ra lỗi NullPointerException.

class Exception2 
{
   public static void main(String args[])
   {
    try{
        String str=null;
        System.out.println (str.length());
    }
        catch(NullPointerException e){
        System.out.println("NullPointerException..");
    }
   }
}

Output:

NullPointerException..

Ở đây, length() là một hàm, nên phải được sử dụng trên một object nào đó. Tuy nhiên, trong ví dụ trên, object str là null nên NullPulumException xảy ra.

Theo: freetuts.net

The post Các ví dụ về exception trong Java appeared first on Sửa Máy Nhanh.

Custom Exception trong Java

phuongle — Sat, 18 Apr 2020 04:19:42 +0000

Trong java đã định nghĩa sẵn các exception class như ArithaturesException, NullPulumException,…v…v… những exception này sẽ được throw ra khi gặp các trường hợp cụ thể nào đó. Ví dụ nếu lấy một số nào đó chia cho 0, bạn sẽ tạo ra một ArithaturesException.

Trong bài trước chúng ta đã học cách sử dụng throw để ném ra exception, ở bài này ta sẽ tiếp tục dùng đến nó để nén ra các custom exception mà ngừoi dùng tự định nghĩa.

Chúng ta có thể tự tạo ra các exception class của riêng mình và ném exception đó bằng cách sử dụng từ khóa throw. Những exception này được gọi là user-defined exception hoặc custom exception. Trong bài viết này, chúng ta sẽ học cách tạo một custom exception và throw nó vào một điều kiện cụ thể.

1. Ví dụ về user-defined exception trong Java

Hãy bắt đầu bằng việc xem xét một ví dụ dưới đây.

/* This is my Exception class, I have named it MyException
 * you can give any name, just remember that it should
 * extend Exception class
 */
class MyException extends Exception{
   String str1;
   /* Constructor of custom exception class
    * here I am copying the message that we are passing while
    * throwing the exception to a string and then displaying 
    * that string along with the message.
    */
   MyException(String str2) {
    str1=str2;
   }
   public String toString(){ 
    return ("MyException Occurred: "+str1) ;
   }
}
class Example1{
   public static void main(String args[]){
    try{
        System.out.println("Starting of try block");
        // I'm throwing the custom exception using throw
        throw new MyException("This is My error Message");
    }
    catch(MyException exp){
        System.out.println("Catch Block") ;
        System.out.println(exp) ;
    }
   }
}

Output:

Starting of try block
Catch Block
MyException Occurred: This is My error Message

Bạn có thể thấy rằng tôi đã tự throw ra một user-defined exception bằng câu lệnh throw new MyException("This is My error Message").

Chú ý rằng:

User-defined exception nghĩa phải extend từ Exception class.
Exception được ném ra bằng cách sử dụng từ khóa throw.

2. Một ví dụ khác về user-defined exception

Throw có thể sử dụng bên trong một phương thức hay một khối lệnh nào đó. Khác với throw, throws lại dùng ngay khi bạn khai báo một phương thức, cẩn thận đừng để bị nhầm lẫn nhé.

Ở ví dụ này, chúng ta đang ném ra ngoại lệ từ một method. Trong trường hợp này, chúng ta nên sử dụng throws nếu không bạn sẽ gặp lỗi biên dịch: “unhandled exception in method”.

class InvalidProductException extends Exception
{
    public InvalidProductException(String s)
    {
        // Call constructor of parent Exception
        super(s);
    }
}
 
public class Example1
{
   void productCheck(int weight) throws InvalidProductException{
    if(weight<100){
        throw new InvalidProductException("Product Invalid");
    }
   }
   
    public static void main(String args[])
    {
        Example1 obj = new Example1();
        try
        {
            obj.productCheck(60);
        }
        catch (InvalidProductException ex)
        {
            System.out.println("Caught the exception");
            System.out.println(ex.getMessage());
        }
    }
}

Output:

Caught the exception
Product Invalid

Trên là một vài ví dụ và cách tự tạo ra một exception trong Java.

Theo: freetuts.net

The post Custom Exception trong Java appeared first on Sửa Máy Nhanh.