Java 线程

线程

进程与线程

进程

进程process:

进程是一个具有一定独立功能的程序在一个数据集上的一次动态执行的过程，是操作系统进行资源分配和调度的一个独立单位，是应用程序运行的载体。进程是一种抽象的概念，从来没有统一的标准定义。进程一般由程序，数据集合和进程控制块三部分组成。

进程的特征

动态性：进程是程序的一次执行过程，是临时的，有生命周期的、是动态产生、动态消亡的；
并发性：任何进程都可以同其他进程一起并发执行；
独立性：进程是系统进行资源分配和调度的一个独立单位；
结构性：进程由程序，数据集合和进程控制块三部分组成；

线程thread:

线程：线程是程序执行中的一个单一的顺序控制流程，是进程内部的的一个执行单元，用来执行应用程序中的一个功能，所有线程在进程中的资源都是共享的，包括全局数据、执行代码等。
多线程：一个应用程序可以同时执行多个功能。

进程与线程的的关系

一个进程中可以包含多个线程，且至少要有一个线程
一个线程必须属于某个进程，进程是线程的容器
一个进程中的多个线程共享该进程的所有资源

进程与线程的区别

线程是程序执行的最小单位，晋城市操作系统分配资源的最小单元
一个进程由一个或多个线程组成县城是一个进程中代码的不同执行路线
进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间（代码段，数据集合、堆等）及一些进程级的资源（如打开文件和信号等），某些进程内的线程在其他进程不可加
调度和切换：线程上下文切换比进程上下文切换要快得多

CPU时间片

CPU分配给各个程序的时间，称为时间片，即该进程允许运行的时间

从表面上各个程序是同时运行的，实际上CPU在同一时间只能执行一个程序
CPU在很短的时间内，在不同程序之间切换，轮流执行每个程序，执行速度很快，所以感觉上是同时运行
　大部分操作系统的任务调度是采用时间片轮转的抢占式调度方式，也就是说一个任务执行一小段时间后强制暂停去执行下一个任务，每个任务轮流执行。任务执行的一小段时间叫做时间片，任务正在执行时的状态叫运行状态，任务执行一段时间后强制暂停去执行下一个任务，被
暂停的任务就处于就绪状态，等待下一个属于它的时间片的到来。这样每个任务都能得到执行，由于CPU的执行效率非常高，时间片非常短，在各个任务之间快速地切换，给人的感觉就是多个任务在“同时进行”，这也就是所说的并发

创建线程

两种方式：

继承Thread类
实现Runnable接口

继承Thread类

步骤：

定义一个类，继承自Thread类，重写run()方法
创建该类的实例，即创建一个线程
调用start()方法，启动线程，不能直接调用run()方法

*
 * JVM 启动时会创建一个主线程，用来执行main方法
 * 实际上，java程序在运行时会至少启动两个线程：main线程、垃圾回收线程gc
 * 要想实现多线程就是在主线程中创建新的线程
 */
public class 继承Threadl类 {
    public static void main(String[] args) {
        System.out.println(11);
        // 创建线程  自定义线程默认名称：Thread-编号，编号从0开始
     MyThread mt = new MyThread("线程1"); 
     //启动线程，使用start()方法,start方法会调用run方法 
     mt.start();
     
     MyThread mt1 = new MyThread("线程2");
     //启动线程，使用start()方法,start方法会调用run方法 
     mt1.start();
     
     // 获取当前线程对象 在哪个调用就获取那个线程
     Thread t = Thread.currentThread() ;
     for(int i=1;i<10000;i++) {
            System.out.println("-----"+ t.getName() +"--------"+i);
        }
    }

}

class MyThread extends Thread{
    
    
    public MyThread() {
        // TODO Auto-generated constructor stub
    }
    
    public MyThread(String name) {
        super(name);
    }
    
    // 在run方法中编写线程要执行的代码
    @Override
    public void run() {
        for(int i=1;i<10000;i++) {
            // getName() 获取线程名
            System.out.println("------" + getName() +"--------"+i);  
        }
    }   
}

实现Runnable接口

步骤

定义一个类，实现Runnable接口，实现run()方法
创建实现类的实例
创建Thread类的一个实例，将上一步中实现类的实例传入
调用start()方法启动线程

public class 实现Runnable接口 {
    public static void main(String[] args) {
        // 2、创建实现类的一个实例
        MyRunnable mr = new MyRunnable();
        
        // 3、创建实例  将Runnable接口的对象传入
        Thread t1 = new Thread(mr);  
        // 启动线程
        t1.start();
        
        // 创建实例
        Thread t2 = new Thread(mr);  // 将Runnable接口的对象传入
        // 启动线程
        t2.start();
        
        for(int i =1;i<=10000;i++) {
            System.out.println("------ "+Thread.currentThread().getName()+ "--------" + i);
        }
        
    }

}
 
class MyRunnable implements Runnable{

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

两种方式的对比

继承Thread类：

线程执行的代码放在Thread类的子类的run()方法中
无法在继承其他类（继承了Thread类、Java是单继承）
实现Runnable接口：
线程执行的代码放在Runnable接口的实现类的run方法中
可以继承自其他类，避免单继承的局限性
适合多个相同程序代码的线程去处理同一个资源
增强程序的健壮性

实例：卖票

public class 对比 {
    public static void main(String[] args) {
        MyThread2 t1 = new MyThread2("窗口1");
        MyThread2 t2 = new MyThread2("窗口2");
        
        t1.start();
        t2.start();
        
        }

}

class MyThread2 extends Thread{
    int num = 100;  // 总票数
    
    public MyThread2(String name) {
        super(name);
    }
    @Override
    public void run() {
        while(num>0) {
            System.out.println(getName() + "--------" + num--);
        }
    }
    
}

结果显示两个窗口各卖了100张票

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

        MyRunnable1 mr = new MyRunnable1();
        Thread t3 = new Thread(mr);
        Thread t4 = new Thread(mr);
        t3.start();
        t4.start();
        }

}


class MyRunnable1 implements Runnable{

    int num = 100; // 总票数
    @Override
    public void run() {
        while(num>0) {
            System.out.println(Thread.currentThread().getName() + "----" + num--);
        }
        
    }
    
}

结果显示两个窗口一共卖了100张票

为什么输出结果可能未按照顺序显示？

线程的生命周期

(

线程捕获.PNG

线程的生命周期相关方法

方法名	作用	说明
start	启动线程，线程进入就绪状态（可运行状态）
sleep	休眠线程，线程从执行状态进入阻塞状态	静态方法，需要捕获异常
yi d	暂停当前线程的执行，让线程从执行状态进入到就绪状态	静态方法
join	暂停当前线程的执行，等待另一个线程执行完毕后在执行，线程从执行状态进入到阻塞状态
interrupt	中断线程的休眠或等待状态

线程安全问题

简介
多个线程同时访问共享数据时可能出现问题

当多线程访问共享数据时，由于CPU的切换，导致一个线程只执行了关键代码的一部分，整个代码还没有执行完
此时另一个线程参与进来，导致共享数据发生异常
解决方案：线程同步机制 synchronized + 锁
被synchronized包围的代码块，被成为同步代码块
被synchronized修饰的方法叫同步方法
锁，也被称为对象锁，每个对象都自带一个锁，且不同对象的锁是不一样的

执行过程：

当线程执行同步代码块或同步方法时，必须获取特定对象的锁才行
且一旦对象的锁被获取了，该对象就不再拥有锁，直到线程执行完同步代码块/同步方法后才会释放对象锁
如果线程无法获取特定对象上的锁时，则线程会进入该对象的锁池中等待，此时会与该锁的线程竞争

public class Ticket implements Runnable{

    private int num = 100; // 总共100张门票
    Object obj = new Object();
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "正在售票");
        while(true) {
            
            synchronized(obj) { // 同步代码块目的就是保护共享数据的安全
                                // 多个线程必须使用同一把锁
            if(num>0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "--售出车票："+ num--);
            }
        }
     }
        
    }

}


public class Test {

    public static void main(String[] args) {
        
        Ticket ticket = new Ticket();
        Thread t1 = new Thread(ticket,"窗口1");
        Thread t2 = new Thread(ticket,"窗口2");
        Thread t3 = new Thread(ticket,"窗口3");
        t1.start();
        t2.start();
        t3.start();

    }
}