文章目录

• • 实现多线程的方式
  • • 1. 继承Thread类
    • 2. 实现Runnable接口
  • 线程加锁同步的方式
  • • 1. ReentrantLock
  • 2. synchronized

实现多线程的方式

1. 继承Thread类
2. 实现Runnable接口
3. 实现Callable接口，线程池

1. 继承Thread类

编写一个线程类，并重写 run() 方法
外部实例化线程，并调用 start() 方法启动前程，执行线程体内的方法

• setName ：设置线程名
• setPriority ：置优先级
• Thread.sleep ：让线程暂停执行
• join：等待这个线程死亡
• wait ：阻塞该线程
• notify ：唤醒该线程

public class MyThread extends Thread{
    @Override
    public void run() {
       for (int i = 1; i <= 30 ;i++){

          // String name = this.getName();
           String name = Thread.currentThread().getName();
           System.out.println(name + ": " + i);
       }
    }
}


public class MyThreadTest {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.setName("thread1");//设置线程名词
        thread1.setPriority(1);//设置线程的优先级
        thread2.setName("thread2");
        thread2.setPriority(10);
        
        Thread.sleep(3000);//设置线程暂停的毫秒数
        thread1.start();//启动线程
        thread2.start();
    }
}

2. 实现Runnable接口

Runnable类是任务类，需要一个线程来承载任务，通过new Thread(new Runnable()).start()来运行任务。
好处是线程体类可以继承其他父类，不受限制。

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}


public class MyRunnableTest {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();

        Thread thread1 = new Thread(myRunnable,"thread1");
        Thread thread2 = new Thread(myRunnable,"thread2");

        thread1.start();
        thread2.start();
    }
}

线程加锁同步的方式

1. ReentrantLock

我们知道synchronized是Java语言层面提供的语法，可以对方法和代码块加锁，控制只能一个线程进入同步区域。

顾名思义，ReentrantLock是可重入锁，它和synchronized一样，一个线程可以多次获取同一个锁。

ReentrantLock，它是Java代码实现的锁，我们可以手动调用lock.lock()获取锁，然后在finally中调用 lock.unlock()正确释放锁。

//计数器
public class Counter {
    private final Lock lock = new ReentrantLock();
    private int count;

    public void add(int n) {
        lock.lock(); //获得锁
        try {
            count += n;
        } finally {
            lock.unlock(); //释放锁
        }
    }
}

笔试题：使用ReentrantLock控制线程的同步执行

• 题目：有A，B，C三个线程,，A线程输出A，B线程输出B， C线程输出C，要求，同时启动三个线程,，按顺序输出ABC，循环10次。

public class ABCRunnable implements Runnable {
    private Lock lock;      //锁对象
    private String name;    //线程名字
    private int flag;       //逻辑取模运算

    public static int count = 0;    //计数（0：A， 1：B  2：C）
    public static final int MAX = 30;   //线程执行30次

    public ABCRunnable(String name, Lock lock, int flag) {
        this.lock = lock;
        this.name = name;
        this.flag = flag;
    }

    @Override
    public void run() {

        while (true) {
            try {
                if (lock.tryLock(1, TimeUnit.SECONDS)) {
                    //尝试获取锁的时候，最多等待1秒。如果1秒后仍未获取到锁，tryLock()返回false，程序就可以做一些额外处理，而不是无限等待下去。
                    if (count >= MAX) {
                        lock.unlock();
                        return;
                    }
                    if (count % 3 == flag) {
                        System.out.println(name);
                        count++;
                    }
                    lock.unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

2. synchronized