流殃的博客

| Comments

实现方式

java 是无法直接操作线程的，是通过C++来操作的

1. 继承Thread类，重写run（）方法

public class thread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("学习多线程"+i);
        }
    }
    public static void main(String[] args) {
        thread thread = new thread();
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("我在学习"+i);
        }
    }
}

2. 实现Runnable接口，重写run（）方法

public class testThread implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("学习多线程"+i);
        }
    }
    public static void main(String[] args) {
        testThread testThread = new testThread();
        Thread thread = new Thread(testThread);
        thread.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习"+i);
        }
    }
}

对比前面两个实现多线程的方法

  • 继承Thread（）类

    • 子类继承Thread具有多线程能力

    • 启动线程：子类对象.start()

    • 不建议使用：避免OOP单继承局限

      oop就是Object Oriented Programming，面向对象编程，

  • 实现Runnable（）接口
    • 实现接口Runnable接口具有多线程能力
    • 启动线程：传入对象+Thread对象.start（）
    • 问题：run方法没有返回值
    • 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

线程不安全：多个线程访问同一个资源的时候，会出现数据数据紊乱的情况，此时把这些线程的状态称作是线程不安全的

3. 实现Callable接口

步骤

  1. 实现Callable接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecuteorService ser=Executors.newFixedThreadPool(1);
  5. 提交执行：Future < Bollean > result1=ser.submit(1)
  6. 获取结果：boolean r1=result1.get()
  7. 关闭服务：ser.shutdownNow();

模拟龟兔赛跑

//龟兔赛跑
public class Race implements Runnable {
    //胜利者
    private static String winner;
    @Override
    public void run() {
        //模拟兔子休息
        if(Thread.currentThread().getName().equals("兔子"))
        {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        for (int i = 0; i <= 100; i++) {
            //判断比赛是否结束
            boolean flag=gameOver(i);
            if(flag)
            {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "米");
        }
    }
    private boolean gameOver(int distance) {
        if (winner != null) {
            return true;
        } else if (distance == 100) {
            winner = Thread.currentThread().getName();
            System.out.println("winner is" + winner);
            return true;
        } else {
            return false;
        }
    }
    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"乌龟").start();
        new Thread(race,"兔子").start();
    }
}

4. 线程池

线程状态

  • 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
  • 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
  • 阻塞(BLOCKED)：表示线程阻塞于锁。
  • 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动力（通知或中断）。
  • 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
  • 终止(TERMINATED)：表示该线程已经执行完毕。

image-1651529587512

初始状态

实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

运行状态

就绪状态

  • 就绪状态只是说你资格运行，调度程序(Cpu)没有挑选到你，你就永远是就绪状态。
  • 调用线程的start()方法，此线程进入就绪状态。
  • 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
  • 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
  • 锁池里的线程拿到对象锁后，进入就绪状态。

运行中状态

线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式

阻塞状态

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

等待状态

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态

超时等待状态

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

终止状态

  1. 当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
  2. 在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常

死锁

四个条件

  • 互斥条件：指线程对已经获取到的资源进行排它性使用，即该资源同时只由一个线程占用。如果此时还有其他线程请求获取该资源，则请求者只能等待，直至占有资源的线程释放该资源。
  • 请求并持有条件：指一个线程已经持有了至少一个资源，但又提出了新的资源请求，而新资源已被其他线程占有，所以当前线程会被阻塞，但阻塞的同时并不释放自己已经获取的资源。
  • 不可剥夺条件：指线程获取到的资源在自己使用完之前不能被其他线程抢占，只有在自己使用完毕后才由自己释放该资源。
  • 环路等待条件：指在发生死锁时，必然存在一个线程—资源的环形链，即线程集合{T0, T1, T2, …, Tn}中的T0正在等待一个T1占用的资源，T1正在等待T2占用的资源，……Tn正在等待已被T0占用的资源。

几个方法比较

  • Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
  • Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。 作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。
  • thread.join()/thread.join(long millis)，当前线程里调用其它线程t的join方法，当前线程进入WAITING/TIMED_WAITING状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程一般情况下进入RUNNABLE状态，也有可能进入BLOCKED状态（因为join是基于wait实现的）。
  • Object.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout) timeout时间到自动唤醒。
  • Object.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。
  • LockSupport.park()/LockSupport.parkNanos(long nanos),LockSupport.parkUntil(long deadlines), 当前线程进入WAITING/TIMED_WAITING状态。对比wait方法,不需要获得锁就可以让线程进入WAITING/TIMED_WAITING状态，需要通过LockSupport.unpark(Thread thread)唤醒。

Comments

评论