java多线程和锁-阿里云开发者社区

java多线程和锁

2023-01-10 78

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 多线程实现方法1: 继承Thread类public class Main { public static void main(String[] args) throws InterruptedException { Worker worker1 = new Worker(); worker1.setName("thread-worker1"); Worker worker2 = new Worker(); worker2.setName("thread_worker2"); worker1.start

多线程实现

方法1: 继承Thread类

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Worker worker1 = new Worker();
        worker1.setName("thread-worker1");
        Worker worker2 = new Worker();
        worker2.setName("thread_worker2");
        worker1.start();
        worker2.start();
        Thread.sleep(1000);
        System.out.println("Main-thread finished!");
    }
}
class Worker extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello " + getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

方法2: 实现Runnable接口

public class Main {
    public static void main(String[] args) {
        Worker worker = new Worker("thread1");
        new Thread(worker).start();
        new Thread(worker).start();
    }
}
class Worker implements Runnable{
    private String name;
   public Worker(String name) {
       this.name = name;
   }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello " + this.name);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

join(long millis): 等待该线程执行结束，父线程才会继续执行; 可以传入一个最长等待时间，超过该时间后继续执行父线程

例如：主线程要等worker1和worker2进程结束后执行

package cc.bnblogs;
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Worker worker1 = new Worker();
        worker1.setName("thread-worker1");
        Worker worker2 = new Worker();
        worker2.setName("thread_worker2");
        worker1.start();
        worker2.start();
        worker1.join(); // 只有worker1执行完成之后才会执行后面的代码
        worker2.join(); // 只有worker2执行完成之后才会执行后面的代码
        System.out.println("Main-thread finished!");
    }
}
class Worker extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello " + getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

interrupt()：从休眠中中断线程

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Worker worker1 = new Worker();
        worker1.setName("thread-worker1");
        Worker worker2 = new Worker();
        worker2.setName("thread_worker2");
        worker1.start();
        worker2.start();
        // 主线程最多等待worker1线程5000ms
        worker1.join(5000);
        worker1.interrupt();  // 抛出InterruptedException异常
        System.out.println("Main-thread finished!");
    }
}
class Worker extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello " + getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // 收到InterruptedException后，结束该线程
                System.out.println(getName() + " stop!");
                break;
            }
        }
    }
}

setDaemon():设置某线程为守护线程

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Worker worker1 = new Worker();
        worker1.setName("thread-worker1");
        Worker worker2 = new Worker();
        worker2.setName("thread_worker2");
        // 将worker1和worker2设置为守护线程
        // 除守护线程之外的其他线程结束后(这里只有主线程)，守护线程会自动结束
        worker1.setDaemon(true);
        worker2.setDaemon(true);
        worker1.start();
        worker2.start();
        // 主线程休眠5s
        Thread.sleep(5000);
        System.out.println("Main-thread finished!");
    }
}
class Worker extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello " + getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException();
            }
        }
    }
}

锁

lock：获取锁，如果锁已经被其他线程获取，则阻塞 unlock：释放锁，并唤醒被该锁阻塞的其他线程

防止读写冲突，同一时间只有一个线程可以拥有锁，并进行写操作

import java.util.concurrent.locks.ReentrantLock;
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Worker worker1 = new Worker();
        worker1.setName("thread-worker1");
        Worker worker2 = new Worker();
        worker2.setName("thread_worker2");
        worker1.start();
        worker2.start();
        worker1.join();
        worker2.join();
        System.out.println("Main-thread finished!");
        System.out.println("cnt: " + Worker.cnt);
    }
}
class Worker extends Thread {
    private static final ReentrantLock lock = new ReentrantLock();
    public static int cnt = 0;
    @Override
    public void run() {
        for (int i = 0; i < 200000; i++) {
            lock.lock();
            try {
                cnt++;
            }finally {
                lock.unlock();
            }
        }
    }
}

同步(Synchronized)

java实现锁的语法糖,继承Thread类和实现Runnable接口的线程使用方式有点区别

还是上面的cnt++的例子

1.继承Thread类

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Worker worker1 = new Worker();
        worker1.setName("thread-worker1");
        Worker worker2 = new Worker();
        worker2.setName("thread_worker2");
        worker1.start();
        worker2.start();
        worker1.join();
        worker2.join();
        System.out.println("Main-thread finished!");
        System.out.println("cnt: " + Worker.cnt);
    }
}
class Worker extends Thread {
    public static int cnt = 0;
    private static final Object object = new Object();
    @Override
    public void run() {
    //锁加到了object对象上,多个线程共享一个object
        synchronized (object) {
            for (int i = 0; i < 200000; i++) {
                cnt++;
            }
        }
    }
}

2.实现Runnable接口

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Worker worker = new Worker();
        Thread worker1 = new Thread(worker);
        Thread worker2 = new Thread(worker);
        worker1.start();
        worker2.start();
        worker1.join();
        worker2.join();
        System.out.println("Main-thread finished!");
        System.out.println("cnt: " + Worker.cnt);
    }
}
class Worker implements Runnable {
    public static int cnt = 0;
    @Override
    public void run() {
        //锁加到了this对象上,而两个线程是由同一个worker创建而来的
        synchronized (this) {
            for (int i = 0; i < 200000; i++) {
                cnt++;
            }
        }
    }
}

也可以直接将synchronized作用到方法上，和上面的代码等价

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Worker worker = new Worker();
        Thread worker1 = new Thread(worker);
        Thread worker2 = new Thread(worker);
        worker1.start();
        worker2.start();
        worker1.join();
        worker2.join();
        System.out.println("Main-thread finished!");
        System.out.println("cnt: " + Worker.cnt);
    }
}
class Worker implements Runnable {
    public static int cnt = 0;
    @Override
    public void run() {
        Worker.work();
    }
    private synchronized static void work() {
        for (int i = 0; i < 200000; i++) {
            cnt++;
        }
    }
}

wait与notify

前面5个线程会等待1s后自动唤醒一个线程，唤醒的线程睡眠1s后叫醒下一个线程

public class Main {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            Worker worker = new Worker(true);
            worker.setName("Thread_" + i);
            worker.start();
        }
        Worker worker = new Worker(false);
        worker.setName("Thread_5");
    // 第6个线程先睡2s再去唤醒线程，这时候已经晚了
        Thread.sleep(2000);
        worker.start();
    }
}
class Worker extends Thread {
    private final boolean needWait;
    // 定义一个全局object
    private static final Object object = new Object();
    public Worker(boolean needWait) {
        this.needWait = needWait;
    }
    @Override
    public void run() {
        synchronized (object) {
            try {
                if (needWait) {
                    // 最多等待1s，超过1s会自动唤醒一个线程
                    object.wait(1000);
                    System.out.println(getName() + " 被唤醒了!");
                    //睡眠1s后继续唤醒其他线程
                    Thread.sleep(1000);
                } else {
                    // 不需要睡眠的线程唤醒一个线程
                    object.notify();
                    System.out.println("尝试唤醒其他线程");
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

当然也可以不使用静态变量object

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        for (int i = 0; i < 5; i++) {
            Worker worker = new Worker(object, true);
            worker.setName("Thread_" + i);
            worker.start();
        }
        Worker worker = new Worker(object, false);
        worker.setName("Thread_5");
        // 第6个线程先睡2s再去唤醒线程，这时候已经晚了
        Thread.sleep(2000);
        worker.start();
    }
}
class Worker extends Thread {
    private final boolean needWait;
    private final Object object;
    public Worker(Object object, boolean needWait) {
        this.object = object;
        this.needWait = needWait;
    }
    @Override
    public void run() {
        synchronized (object) {
            try {
                if (needWait) {
                    // 最多等待1s，超过1s会自动唤醒一个线程
                    object.wait(1000);
                    System.out.println(getName() + " 被唤醒了!");
                    //睡眠1s后继续唤醒其他线程
                    Thread.sleep(1000);
                } else {
                    // 不需要睡眠的线程唤醒一个线程
                    object.notify();
                    System.out.println("尝试唤醒其他线程");
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

java多线程和锁

多线程实现

锁

同步(Synchronized)

wait与notify

热门文章

最新文章

相关课程

相关电子书

相关实验场景