投稿
  1. 起航互联Home
  2. 副业项目

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

例如：主线程要等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);
        }
    }
}

}

原创文章：https://www.qqhhs.com，作者：起航®，如若转载，请注明出处：https://www.qqhhs.com/72.html

版权声明：本站提供的一切软件、教程和内容信息仅限用于学习和研究目的，请于下载的24小时内删除；不得将上述内容用于商业或者非法用途，否则，一切后果请用户自负。本站信息来自网络收集整理，如果您喜欢该程序和内容，请支持正版，购买注册，得到更好的正版服务。我们非常重视版权问题，如有侵权请邮件与我们联系处理。敬请谅解！

Like (0)
Donate 受君之赠，荣幸之至 受君之赠，荣幸之至 受君之赠，荣幸之至 受君之赠，荣幸之至
0 0

待问君好，我是起航 ，一个有着无限可能的流浪疯子。

起航®

起航®

102 文章
10 评论
0 粉丝
每个梦想，都值得灌溉
Previous 2023年1月10日
Next 2023年1月10日

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

联系我们

qhhl

QQ-175142992024110802215838同号

SHARE
TOP
企业建站
icon 联系我们
赞赏
免费午餐
“人们不愿意相信，一个土匪的名字叫牧之”