提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  Java

当前栏目

java多线程和锁

JAVA 线程
2023-03-07 09:15:51 时间

多线程实现 方法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);
        }
    }
}

}

相关文章