线程实现方式。

2019-04-30 23:41:40来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

并发与并行:

并发:多个任务交替执行 (一个人吃两个馒头,两个交替啃)

并行:同时执行。(n个人吃n个馒头)  速度快些。

线程与进程:

进程:进入到内存中的程序叫进程。

线程:

 主线程:

执行主方法(main)的线程

单线程程序:Java程序中只有一个线程,从main方法开始,从上到下依次执行。

JVM执行main方法,main方法会进入栈内存,

然后JVM找到操作系统开辟一条main方法通向cpu的执行路径,

cpu就可以通过这个路径执行main方法,这个路径叫main(主)线程。

多线程:

java程序属于抢占式调度,哪个线程高,哪个线程就优先执行,同一级别随机执行。

创建多线程程序的第一种方式:

java.lang.Thread 类:是描述线程的类,想实现多线程程序,就必须继承该类。

实现步骤: 

  1、创建Thread类的子类。

  2、子类重写run方法, 来设置线程任务。

  3、创建子类对象,调用start()方法,开启新的线程,执行run方法。

  结果是:两个线程并发执行。

public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i=0;i<3;i++){
            System.out.println("run->"+i);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread myThread=new MyThread();
        myThread.start();
        for (int i=0;i<3;i++){
            System.out.println("main->"+i);
        }
    main->0
    run->0
    main->1
    run->1
    main->2
    run->2 } }

多线程运行原理:

new MyThread的时候,又开辟了一条通向cpu的新路径,来执行run方法。

此时,对cpu而言,就有了两条执行路径。

main线程和新线程一起抢夺cpu的执行权。

多线程内存分析:

开始执行程序时,开辟一块栈内存,main方法入栈。

此时,如果直接调用run方法的话,也是在这块栈内存执行run(),也就是仍然

是main线程程序(单线程)程序。

而如果调用的是start(),会另外开辟一块栈空间,run()入栈执行。

Thread类的常用方法:

获取线程名称:

  1、Thread类的方法,getName();

  2、获取当前正在执行的线程 static Thread currentThead(),然后用getName();

第一种:

public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println(getName());
        }
    }
public static void main(String[] args) {
        new MyThread().start();
        new MyThread().start();
        //Thread-0
       // Thread-1
    }

第二种:

public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName());
        //main
    }
}

设置线程名称:

  1、void setName(String name) 2、设置带参构造函数

sleep方法:

  public static void sleep(Long ...) :使当前正在执行的线程以指定毫秒暂停。

 public static void main(String[] args) {
       for (int i=0;i<5;i++){
           System.out.println(i);
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }

创建多线程程序的第二种方式:

实现Runnable接口:

java.lang.Runnable.   实现类必须定义run的无参方法。

java.lang.Thread 类的构造方法:

  1、Thread(Runnable target) 分配新的Thread对象。

  2、Thread(Runnable target,String name)。

实现步骤:

  1、创建Runnable接口的实现类。

  2、重写run方法,设置线程任务。

  3、创建实现类的对象,用含有Runnable接口的构造函数创建Thread类对象。

  4、用start方法,开启新线程执行run();

public class RunnableClass implements Runnable {
    @Override
    public void run() {
        for (int i=0;i<5;i++){
            System.out.println(
                    Thread.currentThread().getName()
                    +"->"+i
            );
        }
    }
}
public static void main(String[] args) {
       RunnableClass runnable=new RunnableClass();
       Thread thread=new Thread(runnable);
       thread.start();
       for (int i=0;i<5;i++){
           System.out.println(
                   Thread.currentThread().getName()
                   +"->"+i
           );
       }
    }

两种实现多线程方法的区别:

实现Runnable接口实现多线程的好处:

  1、避免单继承的局限性: 

    继承了Thread类就不能继承其他类了,而使用接口的方式还可以继承其他类。

  2、增强程序的扩展性,降低了程序的耦合性(解耦):

    用实现Runnable接口的方式,把设置线程任务和开启线程进行分离(解耦 )

匿名内部类实现多线程:

作用:

  简化代码,把实现类实现接口,重写方法,创建实现类方法统一完成。

格式:  new 父类/接口(){重写方法};

 public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                for (int i=0;i<5;i++){
                    System.out.println(currentThread().getName());
                }
            }
        }.start();
       new Thread(new Runnable() {
           @Override
           public void run() {
               for (int i=0;i<5;i++){
                   System.out.println(Thread.currentThread().getName());
               }
           }
       }).start();
    }

 


原文链接:https://www.cnblogs.com/zhangyuhao/p/10770294.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:基于Struts2开发学生信息管理系统 源码

下一篇:Java虚拟机四:垃圾回收算法与垃圾收集器