首页 > 编程语言 > 详细

Java 多线程 01

时间:2020-11-24 11:13:37      阅读:43      评论:0      收藏:0      [点我收藏+]

进程和线程

进程:process,线程:thread

进程是资源分配的基本单位;线程是程序执行的基本单位。

进程拥有自己的资源空间,每启动一个进程,系统就会为它分配地址空间;而线程与CPU资源分配无关,多个线程共享同一进程内的资源,使用相同的地址空间。

同一个进程的多个线程虽然共享程序的内存空间(堆空间等等),但各个线程有独立的栈空间

多核计算机(6核12线程)看到的是线程,指的是同时有12个线程可以并行

技术分享图片

 

 

线程的启动方式:

继承Thread类方式,实现Runnable接口方式,Callable接口方式。

继承Thread方式:

public class ThreadMine extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"计数第"+i+"次");
        }
    }

    public static void main(String[] args) {
        ThreadMine threadMine = new ThreadMine();
        threadMine.setName("secondThread");
        threadMine.start();
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"计数第"+i+"次");
        }
    }
}

直接继承Thread类,重写run方法,new新类的实例,调用.start()即可。

实现Runnable接口的方式:

public class ThreadRun implements Runnable{
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"计数第"+i+"次");
        }
    }

    public static void main(String[] args) {
        ThreadRun threadRun = new ThreadRun();
        new Thread(threadRun,"Thread1").start();
        new Thread(threadRun,"Thread2").start();
        new Thread(threadRun,"Thread3").start();

    }
}

新类实现Runnable接口,重写run方法。new Thread类的实例,参数中放入新类,直接.start()即可。

之所以我们重写的run方法,但调用start方法,是因为静态代理模式,Thread类代理了Runnable接口。

显然采用Runnable接口重写方式有几个好处

  • 这个逻辑关系更像实现接口而非继承
  • 这样可以用同一个类(同一种run方法)开好多个新的线程

Lamada表达式

Lamada表达式来直接简写创建线程:

技术分享图片

 

 

 

线程状态

技术分享图片

 

 

 

技术分享图片

System.out.println(threadMine.getState().toString());//可以输出某个线程的状态

线程状态控制

如何结束线程

 

  • 用stop()和suspend()方法终止,但这两种方法已经过时了,不建议使用。原理上,stop我的理解是会解锁对象,导致有的对象发生不一致。suspend则会有导致死锁的倾向。(这里的原理还需要进一步了解)
  • 置标志位停止,其实是让run方法自行结束。注意,把这个标志位设成volatile的,这表示一个时间内只有一个线程能访问它(但是这个关键字的原理并不是加锁,而是告诉了cpu这个共享的值随时可能被其他线程修改-可见性):https://zhuanlan.zhihu.com/p/42497046
public class ThreadStatus extends Thread{
    public volatile boolean flag=true;

    public void run() {
        while (flag)
        {
            System.out.println(Thread.currentThread().getName() + "线程正在跑着");
        }
        System.out.println("线程结束了");
    }

    public static void main(String[] args) {
        ThreadStatus threadStatus = new ThreadStatus();
        threadStatus.setName("second");
        threadStatus.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadStatus.flag=false;
    }
}

 这种方式只有当run方法在运行的时候才有用,如果线程处于非运行状态(等待,计时等待,阻塞),这种方式就没用了。如果线程被阻塞,它便不能核查共享变量,也就不能停止。此时可以用interrupted()方法打破这种状态。其中断状态将被清除,它还将收到一个InterruptedException异常。这个时候,我们可以通过捕获InterruptedException异常来终止线程的执行,具体可以通过return等退出或改变共享变量的值使其退出。

具体来说,当对一个线程,调用 interrupt() 时,
① 如果线程处于被阻塞状态(例如处于sleep, wait, join 等状态),那么线程将立即退出被阻塞状态,并抛出一个InterruptedException异常。仅此而已。
② 如果线程处于正常活动状态,那么会将该线程的中断标志设置为 true,仅此而已。被设置中断标志的线程将继续正常运行,不受影响。

interrupt() 并不能真正的中断线程,需要被调用的线程自己进行配合才行。
也就是说,一个线程如果有被中断的需求,那么就可以这样做。
① 在正常运行任务时,经常检查本线程的中断标志位,如果被设置了中断标志就自行停止线程。
② 在调用阻塞方法时正确处理InterruptedException异常。(例如,catch异常后就结束线程。)
public class ThreadInterrupt implements Runnable{
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted())
            {
                Thread.sleep(1000);//模仿线程定时等待
                System.out.println("该线程在跑着");
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        finally {
            System.out.println("该线程结束");
        }


    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadInterrupt());
        thread.start();
        Thread.sleep(3000);
        thread.interrupt();

    }
}

 当线程被I/O阻塞的时候,调用interrupt()的情况是依赖与实际运行的平台的。在Solaris和Linux平台上将会抛出InterruptedIOException的异常,但是Windows上面不会有这种异常。

所以处理方式也是在run方法中捕获异常,只是捕获的异常不一样

 

Thread.sleep()定时等待与wait()方法

好像面试常问

整体的区别其实是有四个:

1、sleep是线程中的方法,但是wait是Object中的方法。

2、sleep方法不会释放lock,但是wait会释放,而且会加入到等待队列中。

3、sleep方法不依赖于同步器synchronized,但是wait需要依赖synchronized关键字。

4、sleep不需要被唤醒(休眠之后推出阻塞),但是wait需要(不指定时间需要被别人中断)。

 第一点:好理解,sleep是Thread的静态方法,wait是Object类中的方法。sleep()是线程用来控制自身流程的,把自身暂停一段时间,把执行机会让给其他线程。wait方法用于线程间的通信,这个方法会使拥有该对象锁的进程等待,直到其他线程调用notify()方法,也可以加参数定时。

第二点:sleep是不会释放锁的,看如下例子

public class ThreadSleep implements Runnable{
    public static Object lock=new Object();
    public void run() {
        synchronized (lock)
        {
            System.out.println(Thread.currentThread().getName() + "在运行");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "结束运行");
        }
    }

    public static void main(String[] args) {
        ThreadSleep threadSleep = new ThreadSleep();
        new Thread(threadSleep,"线程1").start();
        new Thread(threadSleep,"线程2").start();
    }
}

输出结果:
技术分享图片

 

 线程1在sleep时并没有释放锁lock,只有它完成后线程2才能拿到锁开始执行。

public class Test {
    private final static Object lock = new Object();
    public static void main(String[] args) {
        Stream.of("线程1", "线程2").forEach(n -> new Thread(n) {
            public void run() {
                Test.testWait();
            }
        }.start());
    }
    private static void testWait() {
        synchronized (lock) {
            try {
                System.out.println(Thread.currentThread().getName()
                                   + "正在执行");
                lock.wait(10_000);
                System.out.println(Thread.currentThread().getName()
                                   + "wait结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

技术分享图片

 

 第三点:依赖同步方法好理解,wait锁的是同步方法中的对象,没有同步方法怎么行。

 

由于sleep不会释放锁,容易导致死锁问题产生,更加推荐wait方法

 

线程礼让 yield

当前线程由运行状态转为就绪状态。

和sleep不一样,只会给相同/更高优先级的线程运行的机会

也不会释放锁

 

线程插队 join

据说了解一下就行

 

技术分享图片

 

 输出线程状态的方式

技术分享图片

 

 守护线程

技术分享图片

 

Java 多线程 01

原文:https://www.cnblogs.com/take-it-easy/p/14009577.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!