java多线程和锁

方法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): 等待该线程执行结束,父线程才会继续执行; 可以传入一个最长等待时间,超过该时间后继续执行父线程

例如:主线程要等worker1worker2进程结束后执行

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();
            }
        }
    }
}

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++;
        }
    }
}

前面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);
            }
        }
    }
}