多线程

多线程介绍
学习多线程之前,我们先要了解几个关于多线程有关的概念。
进程:进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。

什么是多线程呢?即就是一个程序中有多个线程在同时执行。
通过下图来区别单线程程序与多线程程序的不同:
单线程程序:即,若有多个任务只能依次执行。当上一个任务执行结束后,下一个任务开始执行。如,去网吧上网,网吧只能让一个人上网,当这个人下机后,下一个人才能上网。
多线程程序:即,若有多个任务可以同时执行。如,去网吧上网,网吧能够让多个人同时上网。
例子:
public class Demo01 {
    //主线程 :程序从上往下执行的过程  
    //javac编译Demo01
    //JVM 运行你的Demo01的main方法  找操作系统OS 开启线程
    //对于CPU来说就是有一条执行路径  运行方法main的这条路径有个名字叫"main"即主线程
    public static void main(String[] args) {
        System.out.println(0/0);
        method1();
    }
    public static void method1(){
        for(int i=0;i<1000;i++){
            System.out.println(i);
        }
    }
}

 

程序运行原理
分时调度
所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间。
抢占式调度
优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机性),Java使用的为抢占式调度。

创建新执行线程有两种方法。
一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象,开启线程。run方法相当于其他线程的main方法。
另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象,传入到某个线程的构造方法中,开启线程。
方式一:Thread类

 

构造方法

 

常用方法

 

public class ThreadDemo extends Thread{
    public ThreadDemo(){}
    public ThreadDemo(String name){
        super(name);
    }
    public void run() {
        //System.out.println(getName());//获取线程名字
        for(int i=0;i<100;i++){
            try {
                sleep(1000);//休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(i);
        }
    }
}
public class Test {
    //开线程的第一种方法
    //1.定义Thread子类,继承Thread  重写run方法
    //2.在测试类中,创建Thread子对象
    //3.用子类对象调用start方法  只能调用一次
    public static void main(String[] args) {
        //创建线程对象
        ThreadDemo td=new ThreadDemo();
        //开启线程   start:1.让线程执行  2.让JVM调用线程中的run方法
        td.start();
        /*for(int i=0;i<100;i++){
            System.out.println(i+"主");
        }*/
        //获取主线程名字
        Thread td2=Thread.currentThread();
        System.out.println(td2.getName());//main
    }
}
public class Test1 {
    public static void main(String[] args) {
        ThreadDemo td=new ThreadDemo("小野爹");
        //设置线程名称
        td.setName("小野猪");
        //开启线程
        td.start();
    }
}
public class Test2 {
    //休眠一秒执行
    public static void main(String[] args) {
        ThreadDemo td=new ThreadDemo();
        td.start();
    }
}
方式二:实现Runnable接口

 

接口中的方法

 

Thread类构造方法

 

public class MyRunable implements Runnable{
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+" "+i);
        }
    }
}
public class Test {
    //第二种创建线程的方式
    //1.创建实现类,实习Runnable接口,重写run方法
    //2.在测试类中创建实现类对象,创建线程对象,将实现类对象传入线程对象的构造方法
    //3.用线程对象开启线程
    //高内聚,低耦合
    public static void main(String[] args) {
        //创建线程任务对象
        MyRunable mr=new MyRunable();
        //创建线程对象
        Thread t1=new Thread(mr);
        //开启线程
        t1.start();
        Thread t2=new Thread(mr);
        t2.start();
    }
}

 

线程的匿名内部类使用
public class Demo01 {
    //匿名内部类
    //new 抽象类接口(){
        //重写父类方法
    //}.子类独有的方法
    public static void main(String[] args) {
        //多态定义一个runnable实现类对象
        //来描述线程任务
        Runnable r=new Runnable(){
            public void run() {
                System.out.println("1");
            }
        };
        //创建线程
        Thread t=new Thread(r);
        //开启线程
        t.start();
        //也可以一句话实现
        new Thread(new Runnable(){
            public void run() {
                System.out.println("2");
            }
        }).start();
    }
}

 

 

posted @ 2019-01-10 15:50  帅涛  阅读(199)  评论(0编辑  收藏  举报