欢迎访问宙启技术站
智能推送

如何使用Java函数实现线程操作,例如线程创建和同步

发布时间:2023-06-22 02:22:21

Java是一种支持多线程编程的面向对象编程语言。它提供了丰富的线程库和关键字,使得线程操作变得非常容易。在Java中,线程的创建和同步是非常基础的操作,是Java多线程编程的基础。

一、线程创建

Java中创建线程有两种方式:继承Thread类和实现Runnable接口。前者适合继承类的实例可以表示一个线程,后者适于实现类的实例可以作为线程的任务执行。

1. 继承Thread类

继承Thread类是一种创建线程的方式,它要求创建者继承Thread类,并重写run()方法。重写run()方法可以使该线程开始执行,当run()方法执行结束后,该线程将结束。使用继承Thread类可以在子类中重写其他方法来对线程进行更细粒度的控制。

示例:

public class MyThread extends Thread {
    public void run() {
        System.out.println("线程开始执行!");
    }
}

使用继承Thread类的方式创建线程的示例:

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

运行结果:

线程开始执行!

2. 实现Runnable接口

实现Runnable接口是一种创建线程的方式,它要求创建者实现Runnable接口,并重写run()方法。实现Runnable接口相对于继承Thread类来说,有更好的可拓展性,可以实现单继承和多实现的特点。

示例:

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("线程开始执行!");
    }
}

使用实现Runnable接口的方式创建线程的示例:

public class ThreadDemo {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

运行结果:

线程开始执行!

二、线程同步

线程同步是指多个线程在访问共享资源时需要协调彼此之间的执行,保证数据的正确性和一致性。Java线程同步机制是通过以下方式来实现的:

1. Synchronized关键字

Synchronized关键字是Java中实现线程同步的一种方式,它可以修饰方法和代码块,达到加锁的目的。当一个方法被Synchronized修饰时,线程在执行此方法时,会首先尝试获取锁,如果获取不到锁,则线程将会被阻塞。

示例:

public class Account {
    private int balance;

    public synchronized void deposit(int money) {
        balance += money;
    }

    public synchronized void withdraw(int money) {
        balance -= money;
    }

    public int getBalance() {
        return balance;
    }
}

public class Bank implements Runnable {
    private Account account;

    public Bank(Account account) {
        this.account = account;
    }

    public void run() {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            account.deposit(1);
            sum += 1;
        }
        System.out.println("Bank: " + sum);
    }
}

public class Customer implements Runnable {
    private Account account;

    public Customer(Account account) {
        this.account = account;
    }

    public void run() {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            account.withdraw(1);
            sum += 1;
        }
        System.out.println("Customer: " + sum);
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Account account = new Account();
        Bank bank = new Bank(account);
        Customer customer = new Customer(account);
        Thread thread1 = new Thread(bank);
        Thread thread2 = new Thread(customer);
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("余额:" + account.getBalance());
    }
}

运行结果:

Bank: 100

Customer: 100

余额:0

2. Lock接口

Java中的Lock接口也可以实现线程同步,与Synchronized关键字相比,Lock接口提供了更好的可拓展性和更加灵活的锁定机制。通过调用lock()方法,可以获得锁,并由调用者负责解锁。

示例:

public class Account {
    private int balance;
    private Lock lock = new ReentrantLock();

    public void deposit(int money) {
        lock.lock();
        try {
            balance += money;
        } finally {
            lock.unlock();
        }
    }

    public void withdraw(int money) {
        lock.lock();
        try {
            balance -= money;
        } finally {
            lock.unlock();
        }
    }

    public int getBalance() {
        return balance;
    }
}

public class Bank implements Runnable {
    private Account account;

    public Bank(Account account) {
        this.account = account;
    }

    public void run() {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            account.deposit(1);
            sum += 1;
        }
        System.out.println("Bank: " + sum);
    }
}

public class Customer implements Runnable {
    private Account account;

    public Customer(Account account) {
        this.account = account;
    }

    public void run() {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            account.withdraw(1);
            sum += 1;
        }
        System.out.println("Customer: " + sum);
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        Account account = new Account();
        Bank bank = new Bank(account);
        Customer customer = new Customer(account);
        Thread thread1 = new Thread(bank);
        Thread thread2 = new Thread(customer);
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("余额:" + account.getBalance());
    }
}

运行结果:

Bank: 100

Customer: 100

余额:0

三、线程操作总结

Java提供了丰富的线程库和关键字,使得线程操作变得非常容易。在Java中,线程的创建和同步是非常基础的操作,是Java多线程编程的基础。

线程创建:Java中创建线程有两种方式:继承Thread类和实现Runnable接口。

线程同步:线程同步是指多个线程在访问共享资源时需要协调彼此之间的执行,保证数据的正确性和一致性。Java线程同步机制是通过Synchronized关键字和Lock接口来实现的。