• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

java多线程的简单应用

java 来源:OUCFSB 6次浏览

java多线程(后来也叫做并发)是java学习中一种新的思想,当然,并发在java中的学习,只是很基础很浅显的部分,并发更多的涉及操作系统等很多范畴的知识,TIJ中说可以将并发拿出来当做一门单独的学科来学习。所以本文也没有很深入的研究并发的内容,只是来讲解常用的多线程的实现使用方式。想要深入学习的同学可以自己查阅并发相关的知识。
先来讲一下,什么是多线程呢?
多线程可以理解为,计算机在执行一个或多个任务的时候,启动了多个线程共同工作。多线程解决的问题,大致可以分为“速度”和“设计可管理性”两种。特别指出一点,这里的速度,不是说多个cpu执行同一个任务的速度,而是指单个处理器上执行程序的速度。我们说的多线程,指的是单个处理器处理多个线程,而不是指多个处理器的情况。要理清并发和并行的区别。

java中的多线程实现,常用的有两种:继承thread类,实现Runnable接口(还有两种是实现Callable接口和使用Executor来创建线程。Callable接口使用较少,不做讨论。Executor会与线程池放一起讲解)。

继承Thread类

java程序中,可以通过继承java.lang.Thread类,而后重写其run方法接口。值得一提的是,java.lang.Thread也是实现了java.lang.Runnable接口。具体实现,请看代码:
main方法中有用到join()方法,关于本方法的介绍见下文。

public class ThreadDemo extends Thread{ 
    private String name;
    public ThreadDemo(){}

    public ThreadDemo(String name){
        this.name=name;
    }

    public void run(){
        int i=0;
        while(i<=5){
            System.out.println("thread: "+name+" is running! "+i);
            i++;
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        System.out.println("main线程开始执行:");
        ThreadDemo t1=new ThreadDemo("why");
        ThreadDemo t2=new ThreadDemo("sb");
        t1.start();     //启动线程 使线程进入就绪状态,等待cpu调用
        try {
            t1.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        t2.start();
        System.out.println("main线程结束执行");

    }

}

实现Runnable接口

实现Runnable接口也是实现多线程的常用方法,请直接看代码:

public class RunnableDemo implements Runnable{ 
    private String name;



    public RunnableDemo(){}
    public RunnableDemo(String name){
        this.name=name;
    }

    @Override
    public void run() {
        int i=0;
        do{
            System.out.println("Thread :"+name +" is running! "+i);
            try {
                Thread.sleep((int) ((Math.random()*1000)));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }while(i++<6);
    }

    public static void main(String[] args) {
        Thread t1=new Thread(new RunnableDemo("why")); //使用Runnable接口创建多线程时,需要创建Thread的实例来启动线程
        Thread t2=new Thread(new RunnableDemo("sb"));
        t1.start();
        t2.start();

        new Thread(new RunnableDemo("why2")).start(); //等价于上面的方式
        new Thread(new RunnableDemo("sb2")).start();
    }

}

关于使用Thread和Runnable的区别

如果一个类继承Thread,则不适合资源共享。但是如果实现了Runable接口的话,则很容易的实现资源共享。通常来讲,比较建议使用Runnable接口的方式来实现多线程。

总结:

实现Runnable接口比继承Thread类所具有的优势:

1):适合多个相同的程序代码的线程去处理同一个资源

2):可以避免java中的单继承的限制

3):增加程序的健壮性,代码可以被多个线程共享,代码和数据独立

4):线程池只能放入实现Runable或callable类线程,不能直接放入继承Thread的类

重点:线程的状态转换

如果问对于一个初学者来说,学习多线程最重要的部分是什么?我个人认为是线程的状态转换。因为这直接关系到你对线程的理解,和对线程问题的实际解决。下图为盗的一张图:

下面为线程的几种状态:
1、新建状态(New):新创建了一个线程对象,如上面代码中new Thread()后t1的状态即为新建状态。
2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
3、运行状态(Running):就绪状态的线程获取了CPU,执行程序代码。
4、阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权(join,sleep),暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
(一)、等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。(wait会释放持有的锁)
(二)、同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池中
(三)、其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。(注意,sleep是不会释放持有的锁(这也是sleep和wait的区别之一))
5、死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期(线程池中调用shutdown或shutdownNow方法也可以进入本状态)。

线程常用函数说明

①sleep(long millis): 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行),线程进入阻塞状态。
②join():指等待t线程终止。如果某个线程j在另一个线程t上调用t.jion(),那么此线程(j)将会被挂起,直至目标线程t结束才恢复(即t.isAlive()返回为假)。例如Thread的代码案例中,如果main函数中,不添加,t1.join()。那么执行结果应该是:

main线程开始执行:
main线程结束执行
thread: why is running! 0
thread: sb is running! 0
thread: sb is running! 1
thread: why is running! 1
thread: sb is running! 2
thread: why is running! 2
thread: sb is running! 3
thread: why is running! 3
thread: sb is running! 4
thread: why is running! 4
thread: why is running! 5
thread: sb is running! 5

那如果添加了t1.join() (t2不变),输出结果就变成了:

main线程开始执行:
thread: why is running! 0
thread: why is running! 1
thread: why is running! 2
thread: why is running! 3
thread: why is running! 4
thread: why is running! 5
main线程结束执行
thread: sb is running! 0
thread: sb is running! 1
thread: sb is running! 2
thread: sb is running! 3
thread: sb is running! 4
thread: sb is running! 5

需要指出的一点是,main()也是一条线程。所以可以看到,在main线程上添加t1.join()后,main线程会等待t1执行完毕才会继续执行。t2没有添加join方法,所以会正常执行。添加join之后,主线程一定会等子线程都结束了才结束。
③yield():暂停当前正在执行的线程对象,并执行其他线程(退让机制)。
Thread.yield()方法作用是:暂停当前正在执行的线程对象,并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态,以允许具有相同优先级的其他线程获得运行机会。因此,使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是,实际中无法保证yield()达到让步目的,因为让步的线程还有可能被线程调度程序再次选中。

结论:yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下,yield()将导致线程从运行状态转到可运行状态,但有可能没有效果。yield会让同优先级或者高优先级的线程优先执行,若当前处理器并没有同优先级或高优先级的线程,那处理器可能继续选择当前线程执行,也就是说导致yield()并没有作用。
sleep()和yield()的区别
sleep()和yield()的区别):sleep()使当前线程进入停滞状态,所以执行sleep()的线程在指定的时间内肯定不会被执行;yield()只是使当前线程重新回到可执行状态,所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
sleep 方法使当前运行中的线程睡眼一段时间,进入不可运行状态,这段时间的长短是由程序设定的,yield 方法使当前线程让出 CPU 占有权,但让出的时间是不可设定的。实际上,yield()方法对应了如下操作:先检测当前是否有相同优先级的线程处于同可运行状态,如有,则把 CPU 的占有权交给此线程,否则,继续运行原来的线程。所以yield()方法称为“退让”,它把运行机会让给了同等优先级的其他线程
另外,sleep 方法允许较低优先级的线程获得运行机会,但 yield() 方法执行时,当前线程仍处在可运行状态,所以,不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中,如果较高优先级的线程没有调用 sleep 方法,又没有受到 I\O 阻塞,那么,较低优先级线程只能等待所有较高优先级的线程运行结束,才有机会运行。
④setPriority(): 更改线程的优先级。

// MIN_PRIORITY = 1
// NORM_PRIORITY = 5
// MAX_PRIORITY = 10
Thread4 t1 = new Thread4("t1");
Thread4 t2 = new Thread4("t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);

    
⑤interrupt():本方法不是终端线程,它只是向线程发送一个中断信号,让线程在无限等待时(如死锁时)能抛出异常,从而结束线程。但是如果你忽略了这个异常,那么这个线程还是不会中断的。

⑥wait()

Obj.wait(),与Obj.notify()必须要与synchronized(Obj)一起使用,也就是wait,与notify是针对已经获取了Obj锁进行操作,从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){…}语句块内。从功能上来说wait就是说线程在获取对象锁后,主动释放对象锁,同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程,才能继续获取对象锁,并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后,并不是马上就释放对象锁的,而是在相应的synchronized(){}语句块执行结束,自动释放锁后,JVM会在wait()对象锁的线程中随机选取一线程,赋予其对象锁,唤醒线程,继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程,释放CPU控制权,主要的区别在于Object.wait()在释放CPU同时,释放了对象锁的控制。

结合一经典面试题来理解wait()和notify()的用法及作用:

/** * @author fushb * @version 创建时间:2018年5月9日 上午11:40:06 * 类说明 * java多线程中锁的使用,wait(),notify()方法的使用 * 经典面试题目: 建立三个线程,A线程打印10次A,B线程打印10次B,C线程打印10次C,要求线程同时运行,交替打印10次ABC。 */
public class SynchronizedDemo implements Runnable{ 
    private String name;
    private Object prev;
    private Object self;
    public SynchronizedDemo(){}
    public SynchronizedDemo(String name,Object prev,Object self){
        this.name=name;
        this.prev=prev;
        this.self=self;
    }
// MIN_PRIORITY = 1
// NORM_PRIORITY = 5
// MAX_PRIORITY = 10
    @Override
    public void run() {
        int i=0;
        while(i<10){
            synchronized (prev) {
                synchronized (self) {
                    self.notify();          //唤醒当前进程 
                    System.out.print(name);
                    i++;
                }

                try {
                    prev.wait();            //让前置进程wait
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Object a=new Object();
        Object b=new Object();
        Object c=new Object();
        SynchronizedDemo pa=new SynchronizedDemo("A", c, a);
        SynchronizedDemo pb=new SynchronizedDemo("B", a, b);
        SynchronizedDemo pc=new SynchronizedDemo("C", b, c);

        new Thread(pa).start();
        Thread.sleep(100);
        new Thread(pb).start();
        Thread.sleep(100);
        new Thread(pc).start();
        Thread.sleep(100);
    }

}

这里的主要思路为:三个线程的切换执行,需要保证三个线程轮流执行且顺序不能错误。那就需要使用Synchronized方法来对对象进行加锁。且只有前置对象和本对象的锁同时获取到时,才能执行打印操作。所以执行思路是:获取前置对象锁(保证前置对象线程没有执行);获取本对象锁(保证本对象没有被其他线程占用);唤醒本对象,打印本对象;让前置对象wait()等待轮换线程时唤醒前置对象(为了防止执行完本线程后,处理器获取前置对象的线程进行打印,这样就不能保证打印的顺序了。所以需要执行完本次打印后,让前置对象wait()等待下次唤醒)。程序逻辑有一个bug,就是初始化状态的问题。按照题目要求,你需要按照A–B–C的顺序来启动,不然会导致其他的打印顺序出现。
⑦sleep()方法
sleep()使当前线程进入停滞状态(阻塞当前线程),让出Cpu的使用。目的是不让当前线程独自霸占该进程所获的CPU资源,以留一定时间给其他线程执行的机会;
   sleep()是Thread类的Static(静态)的方法;因此他不能改变对象的机锁,所以当在一个Synchronized块中调用Sleep()方法是,线程虽然休眠了,但是对象的机锁并木有被释放,其他线程无法访问这个对象(即使睡着也持有对象锁)。
  在sleep()休眠时间期满后,该线程不一定会立即执行,这是因为其它线程可能正在运行而且没有被调度为放弃执行,除非此线程具有更高的优先级。
   wait和sleep区别
共同点:
1. 他们都是在多线程的环境下,都可以在程序的调用处阻塞指定的毫秒数,并返回。
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ,从而使线程立刻抛出InterruptedException。
如果线程A希望立即结束线程B,则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep /join,则线程B会立刻抛出InterruptedException,在catch() {} 中直接return即可安全地结束线程。
需要注意的是,InterruptedException是线程自己从内部抛出的,并不是interrupt()方法抛出的。对某一线程调用 interrupt()时,如果该线程正在执行普通的代码,那么该线程根本就不会抛出InterruptedException。但是,一旦该线程进入到 wait()/sleep()/join()后,就会立刻抛出InterruptedException 。
不同点:
1. Thread类的方法:sleep(),yield()等
Object的方法:wait()和notify()等
2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互,来实现线程的同步。
sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法。
3. wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用 。
4. sleep必须捕获异常,而wait,notify和notifyAll不需要捕获异常。
所以sleep()和wait()方法的最大区别是:
    sleep()睡眠时,保持对象锁,仍然占有该锁
    而wait()睡眠时,释放对象锁
  但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态,从而使线程立刻抛出InterruptedException(但不建议使用该方法)。
  

java线程池

java中也可以使用线程池的方式来创建多线程。本文做简单介绍,详细请看其他博客。
线程池的常用类:ExecutorService(创建线程池的接口),Executors(工具类)。
使用线程池创建线程:


        Object a=new Object();
        Object b=new Object();
        Object c=new Object();
        SynchronizedDemo2 pa=new SynchronizedDemo2("A", c, a);
        SynchronizedDemo2 pb=new SynchronizedDemo2("B", a, b);
        SynchronizedDemo2 pc=new SynchronizedDemo2("C", b, c);

        ExecutorService e=Executors.newCachedThreadPool(); //创建可变的线程池
        e.execute(pa);//执行线程
        Thread.sleep(100);
        e.execute(pb);
        Thread.sleep(100);
        e.execute(pc);
        Thread.sleep(100);
        e.shutdownNow();        //关闭ExecutorService

版权声明:本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。
喜欢 (0)