java线程详解

一、基本概念

1、进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。
2、线程是指进程中的一个执行流程，一个进程可以运行多个线程。比如java.exe进程可以运行很多线程。线程总是属于某个进程，线程没有自己的虚拟地址空间，与进程内的其它线程一起共享分配给该进程的所有资源。
3、线程“同时”执行只是人的感觉，在线程之间实际上轮换执行。

4、进程在执行过程中拥有独立的内存单元，进程有独立的地址空间。一个进程中的多个线程共享进程的内存块。当有新的线程产生的时候，操作系统不分配新的内存，而是让新线程共享原有的进程块的内存。因此，线程间的通信很容易，极大的提高了程序的运行效率。不同的进程因为处于不同的内存块，因此进程之间的通信相对困难。
5、线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器,一组寄存器和栈）。

6、线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程包含以下内容：

（1）一个指向当前被执行指令的指令指针。

（2）一个栈。

（3）一个寄存器值的集合，定义了一部分描述正在执行线程的处理器状态的值。

（4）一个私有的数据区。

7、多任务就是同一时刻运行多个程序的能力。每一个任务称为一个线程。线程是进程中负责执行程序的一个执行控制单元，线程负责程序的执行，而一个进程允许有多个控制单元，我们称为多线程。

8、Java编写程序都运行在Java虚拟机（JVM）中，在JVM的内部，程序的多任务是通过线程来实现的。每用java命令启动一个java应用程序，就会启动一个JVM进程。在同一个JVM进程中，有且只有一个进程，就是它自己。在这个JVM环境中，所有程序代码的运行都是以线程来运行。
  9、在Java中，每次程序运行至少启动2个线程，而且每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行。每当使用java命令执行一个类时，实际上都会启动一个JVM,每一个JVM实际上就是在操作系统中启动一个进程。java本身具备了垃圾回收机制，所以每个java运行时至少会启动两个线程，一个main线程，另外一个是垃圾回收机制，JVM找到程序的入口点main()，然后运行main()方法，这样就产生了一个线程，这个线程称之为主线程。一旦再创建一个新的线程，就产生一个新的调用栈。当main方法结束后，主线程运行完成，JVM进程也随即退出。

10、线程分为两类：用户线程和守候线程。守护线程是依赖于用户线程，用户线程退出了，守护线程也就会退出，典型的守护线程如垃圾回收线程。用户线程是独立存在的，不会因为其他用户线程退出而退出。默认情况下启动的线程是用户线程,通过setDaemon(true)将线程设置成守护线程,这个函数务必在线程启动前进行调用，否则会报java.lang.IllegalThreadStateException异常,启动的线程无法变成守护线程,而是用户线程。

总结：

一个进程里面，至少有一个线程。

多线程的优点：解决了我们需要同时运行多代码的问题。

缺点：线程太多会降低效率。

二、线程的定义

1、在Java中，“线程”指两件不同的事情：

   （1）java.lang.Thread类的一个实例；

   （2）线程的执行。

 2、在 Java程序中，有两种方法创建线程：

   （1）对 Thread 类进行派生并覆盖run方法；

   （2）通过实现Runnable接口创建。

    Java中线程是指使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。

三、线程创建与启动的实例

1、使用析构函数（finalize）进行垃圾回收和主线程进行构造演示多线程

public class Student {
    private String name;

    Student(String name){
        this.name = name;
        System.out.println(name + "被构造了");
    }

    //回收对象的时候，由对象的垃圾回收器调用此方法
    @Override
    protected void finalize() throws Throwable {
        System.out.println(name + "被回收了");
    }
}

测试

public class Test {
    public static void main(String[] args) {
        new Student("胡井号");//匿名对象
        new Student("张三");
        new Student("李四");
        new Student("王五");
        System.gc();//运行垃圾回收器
        System.out.println("执行完毕");
    }
}

2、创建线程的第一种方式：

（1）继承Thread类

（2）重写Thread类里面的run方法

（3）创建线程的子类对象

（4）调用start方法启动线程

public class Dog extends Thread{
    @Override
    public void run() {
     System.out.println(Thread.currentThread().getName());//返回当前正在执行的线程对象的名字
        for (int i = 0;i<100;i++){
            System.out.println("狗在跑");
        }
    }
    public void shout(){
        System.out.println(Thread.currentThread().getName());
        for (int i = 0;i<100;i++){
            System.out.println("汪汪汪");
        }
    }
}

测试

public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.start();//调用start方法，开启线程，运行run方法
        dog.shout();//调用shout方法的时候，开启的是主线程（main）
    }
}

局限性：不能再继承别的类了

3、创建线程的第二种方法：

（1）定义类实现Runnable接口（）

（2）实现接口里的run方法，也就是将线程要执行的任务封装在run方法中

（3）创建一个线程对象，然后将实现Runnable接口的类作为创建线程对象的构造方法的参数传入

（4）调用线程对象的start方法，启动线程

 

Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。

public class Dog implements Runnable { //实现Runnable接口
    @Override
    public void run() {
        System.out.println("狗在跑~");
    }
    public void shout(){
        System.out.println("汪汪汪~");
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Thread thread = new Thread(dog);//创建线程对象，把dog对象放到线程中
        thread.start();//开启线程
        dog.shout();
        System.out.println("执行完毕");

    }
}

4、创建线程的第三种方法：匿名内部类启动线程

public class Game {
    public static void begin(){
        new Thread(){ //创建匿名对象
            @Override
            public void run() {
                super.run();
            }
        }.start();//启动线程
    }

    public static void main(String[] args) {
        begin();//调用静态方法
    }
}

5、线程安全问题：

（1）多线程操作共享数据

（2）操作共享数据的代码有多条

解决办法：同步代码块

好处：解决了线程安全问题

弊端：降低了效率，每次都要去判断同步锁（synchronized）

买票案例：

public class Ticket implements Runnable{
    private int num = 100;//定义票数
   Object object = new Object();//创建Object对象

    @Override
    public void run() {
        try {
            sale();//调用售票的方法
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void sale() throws InterruptedException {
        while (true) {
            synchronized (object) {//同步锁
                if (num > 0) {
                    Thread.sleep(100);//线程休眠100秒
                    //获得线程对象的名字，然后票数减1
                    System.out.println(Thread.currentThread().getName() + "卖了" + num--);
                } else {
                    break;//不卖票的话需要停止，不然会陷入死循环
                }
            }
        }
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        //Thread的构造函数用的是两个参数的，一个是要开启线程的对象和线程的名字
        Thread thread1 = new Thread(ticket,"张三");
        Thread thread2 = new Thread(ticket,"李四");
        Thread thread3 = new Thread(ticket,"王五");
        Thread thread4 = new Thread(ticket,"赵六");
        Thread thread5 = new Thread(ticket,"胡井号");

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
        thread5.start();
    }
}

在买票过程中cpu会来回切换要执行的线程，当卖完票的时候，票数还没减的时候，又去执行另一个线程，会造成买到同一张票的线程安全问题，所以用完同步锁后，就可以执行完这个同步代码块的内容后才能去执行其他的线程

同步代码块和同步函数：

同步代码块的锁是任意对象，同步函数的锁是this

 

死锁常见的的情形之一：同步代码块的嵌套

例子：

public class MyLock {
    public static final Object LOCKA = new Object();//创建锁A对象
    public static final Object LOCKB = new Object();//创建锁B对象
}

public class DeathLock implements Runnable {
    private boolean flag;

    public DeathLock(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        if (flag) { //如果为true就进入锁A和锁B
            synchronized (MyLock.LOCKA) {
                System.out.println(Thread.currentThread().getName() + "if的LOCKA");
                synchronized (MyLock.LOCKB) {
                    System.out.println(Thread.currentThread().getName() + "if的LOCKB");
                }
            }
        } else { //为false就进入锁B和锁A
            synchronized (MyLock.LOCKB) {
                System.out.println(Thread.currentThread().getName() + "else的LOCKB");
                synchronized (MyLock.LOCKA) {
                  System.out.println(Thread.currentThread().getName() + "else的LOCKA");
                }
            }
        }
    }
}

测试

public class Test {
    public static void main(String[] args) {
        DeathLock d1 = new DeathLock(true);
        DeathLock d2 = new DeathLock(false);

        Thread t1 = new Thread(d1);
        Thread t2 = new Thread(d2);

        t1.start();
        t2.start();
    }
}

6、线程调度：

（1）线程优先级设置

public class Talk implements Runnable{
    private String name;

    public Talk(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("我叫" + name + i);
        }
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Talk t = new Talk("董事长");
        Talk a = new Talk("职员");

        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(a);

        thread1.setPriority(Thread.MAX_PRIORITY);//调用线程更改优先级的方法(最高级)
        thread2.setPriority(Thread.MIN_PRIORITY);//调用线程更改优先级的方法（最低级）

        thread1.start();
        thread2.start();
    }
}

（2）线程插队

public class Talk implements Runnable{
    @Override
    public void run() {
        System.out.println("我在说话");
    }
}

测试

public class Test {
    public static void main(String[] args) throws InterruptedException {
        Talk t = new Talk();
        Thread thread = new Thread(t);
        thread.start();

        for (int i = 0;i<5;i++){
            System.out.println("我是主线程");
            if (i==3){
                thread.join();//插队
            }
        }
    }
}

（3）线程让步

public class Talk implements Runnable{
    private String name;

    public Talk(String name) {
        this.name = name;
    }
    @Override
    public void run() {
        for (int i = 0;i<10;i++){
            System.out.println("我叫" + name + i);
            Thread.yield();//让步
        }
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Talk t = new Talk("董事长");
        Talk a = new Talk("职员");

        Thread thread1 = new Thread(t);
        Thread thread2 = new Thread(a);

        thread1.start();
        thread2.start();
    }
}

7、生产者消费者问题

资源类

public class Resource {
    private String name;
    private int id = 1;//编号
    private boolean flag = false;//为true时生产，生产完把flag的值改为true时就能消费了，消费完把值改为false

    public synchronized void set(String name){ //同步函数
        if (!flag){ //如果为true
            this.name = name + id;
            System.out.println(Thread.currentThread().getName() + "生产了" + this.name);
            this.flag = true;//把默认的false变成true
            id++;
            notify();//唤醒单个线程
        }else {
            try {
                this.wait();//线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void out(){
        if (flag){
            System.out.println(Thread.currentThread().getName() + "消费了" + this.name);
            this.flag = false;
            notifyAll();//唤醒所有线程
        }else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

生产者类

public class Producer implements Runnable{
    private Resource r;//把资源类作为属性

    public Producer(Resource r) {
        this.r = r;
    }
    @Override
    public void run() {
       while (true){
           this.r.set("烤鸭");//调用资源类的set方法
       }
    }
}

消费者类

public class Consumer implements Runnable{
    private Resource r;

    public Consumer(Resource r) {
        this.r = r;
    }
    @Override
    public void run() {
        while (true){
            this.r.out();//调用资源类的out方法
        }
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Resource r = new Resource();//创建资源对象
        Producer p = new Producer(r);//创建生产者对象
        Consumer c = new Consumer(r);//创建消费者对象

        //一个生产者，多个消费者
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);
        Thread t3 = new Thread(c);
        Thread t4 = new Thread(c);
        Thread t5 = new Thread(c);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
}