java线程

Java线程

进程和线程

1.进程：

当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

2.线程：

线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。

Java中的线程

一.线程分类

（1）.单线程
若有多个任务只能依次执行。
（2）.多线程
若有多个任务可以同时执行
（3）.主线程
jvm 启动后，必然有一个执行路径(线程)从 main 方法开始的，一直执行到 main 方法结束，这个线程在 java 中称之为主线程。

二.线程的实现

1.继承Thread类
创建线程的步骤：

• a.定义一个类继承 Thread。
• b. 重写 run 方法。
• c. 创建子类对象，就是创建线程对象。
• d. 调用 start 方法，开启线程并让线程执行，
• 同时还会告诉 jvm 去调用 run 方法。
  如下示例：

public class ThreadA extends Thread {
    /**
     * 线程的任务写在run方法中
     */
    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }

    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        //设置线程的名字
        threadA.setName("得力");
        //设置线程的优先级
        threadA.setPriority(10);
        ThreadA threadA1 = new ThreadA();
        //设置线程的名字
        threadA1.setName("得力1");
        threadA1.setPriority(Thread.MIN_PRIORITY);
        threadA1.start();
        threadA.start();
        System.out.println(threadA.getPriority());
        System.out.println(threadA1.getPriority());

    }
}

*** 2.实现Runnable接口***
使用原因：a.避免了继承Thread类的单继承局限性
b.对线程对象和线程任务进行解耦
创建线程的步骤：

• 1、定义类实现 Runnable 接口。
• 2、覆盖接口中的 run 方法。。
• 3、创建 Thread 类的对象
• 4、将 Runnable 接口的子类对象作为参数传递给 Thread 类的构造函数。
• 5、调用 Thread 类的 start 方法开启线程。
  如下展示：

public class ThreadB implements  Runnable {


    @Override
    public void run() {
        for (int i = 0; i <1000 ; i++) {
            System.out.println(Thread.currentThread().getName()+"---->"+i);
        }
    }

    public static void main(String[] args) {

        ThreadB threadB = new ThreadB();

        Thread thread1 = new Thread(threadB,"aa");

        Thread thread2 = new Thread(threadB,"bb1");

        //启动线程
        thread1.start();
       // thread2.start();
        Thread thread3 = new Thread(threadB,"bb2");


       // thread2.run();
       // thread3.run();


    }
}

3.匿名内部类
如下展示创建过程：

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

        System.out.println("-----main begin------------");
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <1000 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"---===>"+i);
                }
            }
        }.start();

        System.out.println("------===========------------");
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <1000 ; i++) {
                    System.out.println(Thread.currentThread().getName()+"---===>"+i);
                }
            }
        }.start();

        System.out.println("-----------main over--------------");
    }
}

4.线程池
1.概念：线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

2.用途：主要用来解决线程生命周期开销问题和资源不足问题

3.使用方式：两种
a.实现Runnable接口,创建过程：
<1>.创建线程池工厂
<2>.创建Runnable实例对象
<3>.从线程池中获取线程对象的run()
<4>.关闭线程池
代码展示：

package com.it.threadpool;

public class ThreadRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+i+"进入电影院");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+i+"离开电影院");
        }
    }
}

Runnable测试类

package com.it.threadpool;


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadRunnablePool {
    public static void main(String[] args) {
        //创建线程池工厂
        ExecutorService service = Executors.newFixedThreadPool(5);
        //创建Runnable实例对象
        ThreadRunnable threadRunnable = new ThreadRunnable();
        //从线程池中获取线程对象的run()
        service.submit(threadRunnable);
        //关闭线程池
        service.shutdown();
    }

}

b.实现Callable接口,创建过程：
<1>.创建线程池工厂
<2>.创建Callable接口子类对象
<3>.提交Callable接口子类对象
<4>.关闭线程池
代码展示：

package com.it.threadpool;

import java.util.concurrent.Callable;

public class ThreadCallable implements Callable {
    @Override
    public Object call() throws Exception {
        System.out.println("我要一个教练:call");
        Thread.sleep(2000);
        System.out.println("教练来了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完后,教练回到了游泳池");
        return null;
    }
}

Callable代码测试部分

package com.it.threadpool;

        import java.util.concurrent.ExecutorService;
        import java.util.concurrent.Executors;

public class ThreadCallablePool {
    public static void main(String[] args) {
        //创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(5);
        //创建Callable实例对象
        ThreadCallable threadCallable = new ThreadCallable();
        //调用实例对象的run方法
        service.submit(threadCallable);
        //关闭线城池
        service.shutdown();
    }
}

三.线程的状态

1.新建（NEW）
2.就绪/可运行（RUNNABLE）
3.运行（RUNNING）
4.阻塞（BLOCKED/WAITING/TIMED_WAITING）

5.死亡（TERMINATED ）

四.线程的优先级

1.方法：
final void setPriority(int newPriority)：更改线程的优先级。
final int getPriority()：返回线程的优先级。
2.常量：
NORM_PRIORITY：值为 5（默认值）
MAX_PRIORITY：值为 10
MIN_PRIORITY：值为 1
3.作用
a.优先级决定了线程占用CPU的概率，较高优先级的线程占用CPU的可能性较大。
b.合理设置优先级是实现线程调度策略的手段之一。
4.注意
优先级确定的仅是宏观上的概率和可能性。

五.线程的调度

1.概念
合理分配多个线程对CPU资源占用，即线程调度
2.原因
多线程对CPU大量需求与CPU的数量不足之间的矛盾。
3.实现手段：a.合理设定优先级
b.使用Thread.yield()、Thread.sleep()、join()等方法等等
4.策略
时间片轮转发
抢占式调度