13Java第十三章线程

程序、进程、线程

程序：在计算机上安装的程序代码（静态的）。

进程：运行中的程序，从硬盘上被加载到内存中，分配空间，是操作系统分配空间的单位。

线程：线程是进程内部的最小执行单元（单位），是操作系统调度单位。

举例：QQ

安装到电脑上（静态代码） 双击运行：加载到内存中

CPU执行以线程为单位。

线程、进程的关系

线程隶属于进程。

一个进程中可以包含多个线程，一个进程中至少包含一个线程（即主线程）。

可以在主线程中创建其他线程。

main方法

用来启动java主线程的。

线程

线程是操作系统调度执行的单位，线程是具备可以独立执行的。如果是多线程，那么两个线程可以是同时执行的。

线程是一个可以独立被操作系统执行调度的，多核CPU下，同时可以执行多个线程。

创建线程

//此程序非多线程！ 
//这种现象它只是方法调用，程序会按照调用的先后顺序执行。
public class Sample {
    
    public void method1(String str){
    
        System.out.println(str); 
    }
    public void method2(String str){
    
        method1(str); 
    }
    public static void main(String[] args) {
    
        Sample s = new Sample(); s.method2("hello!"); 
    } 
}

继承线程的两种方式

继承Thread类的方式

不可以再继承其他类。

extends Thread：

MyThread myThread = new MyThread();

myThread.start();

/*
   自己独立的创建一个线程
   方式一：继承自Thread类，重写run()方法
*/
public class MyThread extends Thread{
   
    //线程中执行的任务代码必须写在run（）中
    @Override
    public void run(){
   
        for (int i = 0; i < 1000; i++) {
   
            System.out.println("MyThread:"+i);
        }
    }
}

public class Test {
   
    //启动java主线程
    public static void main(String[] args) {
   
        //创建自己实现的线程对象
        MyThread myThread = new MyThread();
//        myThread.run(); 调用run()方法，并非启动线程，就是普通的方法调用。
        //启动线程，并不是启动后就会立即执行。在操作系统处排上队了，什么时候执行由操作系统调度算法决定。
        myThread.start();
        System.out.println("main结束运行"); //此时已经是多线程了
        for (int i = 0; i < 100; i++) {
   
            System.out.println("main"+i);
        }

    }
}

实现Runnable接口的方式

还可以继承其他类。

implements Runnable：

ThreadDemo threadDemo = new ThreadDemo();

Thread thread = new Thread(threadDemo);

thread.start();

/*
  创建线程方式二：
  implements Runnable只是来编写线程要做的事情
*/
public class ThreadDemo implements Runnable{
   
    @Override
    public void run(){
   
        for (int i = 0; i < 1000; i++) {
   
            System.out.println("ThreadDemo:"+i);
        }
    }
}

public class Test {
   
    public static void main(String[] args) {
   
        //方式2
        //创建线程的执行任务，并不是线程。
        ThreadDemo threadDemo = new ThreadDemo();
        //Thread是线程的管理类，创建线程，并为其分配任务。
        Thread thread = new Thread(threadDemo);
        //启动线程
        thread.start();
        for (int i = 0; i < 100; i++) {
   
            System.out.println("main"+i);
        }
    }
}

Thread类

Thread类是用来管理线程的。

run（）方法：实现线程任务

start（）方法：启动线程

currentThread()：获得当前执行的线程

线程是有优先级的，优先级范围是1-10，默认是5。

SetPriority(int newPriority)：设置线程的优先级

getPriority()：返回线程的优先级

以下三个方法会影响线程的状态。

join（）：等待当前线程结束。

sleep（）：线程休眠指定的时间。

yield（）：线程主动让出。

线程优先级

优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级。

较高优先级的线程有更多的机会获得CPU的执行权（不是绝对的）。

public class ThreadDemo implements Runnable{
   
    @Override
    public void run(){
   
        System.out.println("thread:"+Thread.currentThread().getPriority()); //优先级
    }
}

public class Test {
   
    public static void main(String[] args) {
   
        //方式2
        //创建线程的执行任务，并不是线程。
        ThreadDemo threadDemo = new ThreadDemo();
        /*
        //创建线程对象
        Thread t = new Thread();
        Thread t = new Thread("mythread");
        Thread thread = new Thread(threadDemo);
        Thread thread = new Thread(threadDemo,"mythread");*/
        Thread thread = new Thread(threadDemo);

        thread.setName("mythread111"); //为线程设置名称
        thread.start();

        thread.setPriority(3);
        Thread.currentThread().setPriority(10); //main优先级设置为10

//        System.out.println("thread:"+thread.getPriority()); //优先级
        System.out.println("main:"+Thread.currentThread().getPriority()); //优先级
    }
}

调度策略

• 时间片

• 抢占式：高优先级的线程抢占CPU。

Java的调度方法

• 同优先级线程组成先进先出队列，使用时间片策略。

• 对高优先级，使用优先调度的抢占式策略。

线程生命周期

生命周期：就是什么时候创建，又什么时候销毁（死亡）。

五种状态

新建

MyThread t = new MyThread( );

就绪

运行

阻塞

死亡

sleep()：线程休眠指定的时间。

public class ThreadDemo implements Runnable{
   
    @Override
    public void run(){
   
        for (int i = 0; i < 100; i++) {
   
            try {
   
                Thread.sleep(1000);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class Test {
   
    public static void main(String[] args) {
   

        ThreadDemo threadDemo = new ThreadDemo();
        Thread thread = new Thread(threadDemo);
        thread.start();
    }
}

yield()：可以直接从运行状态回到就绪队列中

public class ThreadDemo implements Runnable{
   
    @Override
    public void run(){
   
        for (int i = 0; i < 100;