线程

进程：是系统进行资源调度的基本单位，进入到内存的程序。

线程：是CPU调度和分配的基本单位。线程属于进程，进程中的一个执行单元，负责程序的执行。

线程调度

    分时调度：轮流使用cpu的使用权，平均分配每个线程的使用时间

    抢占调度：优先让优先级高的使用cpu，优先级相同随机选择一个线程

线程的创建

    1.继承Thred类

/**

* @program: Sword_to_Offer

* @author: GoKu

* 创建多线程程序的第一种方法 ：创建Thread类的子类

* 每次打印的结果都不一样

* @create: 2019-09-24 13:17

*/

public class Thred1 {

     static class MyThred extends Thread{

        public void run() {

            for(int i = 0;i < 10;i++){

                System.out.println(i);

            }

        }

    }

    public static void main(String[] args) {

        MyThred t = new MyThred();

        t.start();

        String s = t.getName();//该线程的名称

        t.sleep(1000);//线程停止1S

        Thread.currentThread().getName();//获取当前线程得名称

        t.setName("sss");//改变线程得名称

        for(int i = 0;i < 10;i++){

            System.out.println(i);

        }

    }

}

    2.实现Runnable接口创建线程

/**

* @program: Sword_to_Offer

* @author: GoKu

* 使用Runnable接口实现

* @create: 2019-09-24 14:05

*/

public class Thred2 {

    static class mythred implements Runnable{

        @Override

        public void run() {

            for(int i = 0; i< 10;i++){

                System.out.println(Thread.currentThread().getName() + i);

            }

        }

    }

    public static void main(String[] args) {

        mythred mt = new mythred();

        Thread s = new Thread(mt);

        s.start();

    }

}

3.实现Callable接口

    与Runnable比 有返回值，可以抛出异常，支持泛型的返回值，需要借助Future Task类

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

/**

* @program: Sword_to_Offer

* @author: GoKu

* 实现Callable接口

* @create: 2019-09-25 13:18

*/

class Numthred implements Callable{

@Override

    public Object call() throws Exception {

        int sum = 0;

        for(int i = 1;i < 100;i++){

            if(i % 2 == 0){

                System.out.println(i);

                sum = sum + i;

            }

        }

        return sum;

    }

}

public class CallabletTest {

    public static void main(String[] args) {

        //创建Callable实现类的对象

        Numthred n = new Numthred();

        //创建FutureTask对象

        FutureTask f = new FutureTask(n);

        //创建Thred对象，调用start（）方法

        new Thread(f).start();

        Object sum;

            try {

                //取到返回的对象

                sum = f.get();

                System.out.println("总和为" +sum);

            } catch (InterruptedException e) {

                e.printStackTrace();

            } catch (ExecutionException e) {

                e.printStackTrace();

            }

    }

}

如何理解Callable比Runnable强大

    1.call可以有返回值

    2.call可以抛出异常，被外面的操作捕获

    3.Callable支持泛型

4.使用线程池

提前创建好多个线程池，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似公共交通

    1.提高响应速度

    2.降低资源消耗

    3.便于线程管理

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ThreadPoolExecutor;

/**

* @program: Sword_to_Offer

* @author: GoKu

* 线程池创建线程

* @create: 2019-09-25 13:45

*/

class Numt implements Callable {

    @Override

    public Object call() throws Exception {

        for(int i = 1;i < 100;i++){

            if(i % 2 == 0){

                System.out.println(i);

            }

        }

        return null;

    }

}

class P implements Runnable {

    public synchronized void run() {

        for (int i = 1; i < 100; i++) {

            if (i % 2 == 0) {

                System.out.println(i);

            }

        }

    }

}

public class ThreadPool {

    public static void main(String[] args) {

        //提供指定线程数量的线程池

        ExecutorService service = Executors.newFixedThreadPool(10);

        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;

        //设置线程池的属性

        service1.setCorePoolSize(20);

        //执行指定线程的操作

        service.execute( new P()); //runnable接口

        //关闭连接池

        service.shutdown();

        //service.submit(); //callable接口

    }

}

线程的生命周期

   

 

线程的同步

    当某个线程操作数据的时候，其他线程也来操作数据，就会出现问题。

解决：

    1.同步代码块synchronized（同步监视器）{需要对同步的代码}

        说明：操作共享数据的代码即为同步代码

        共享数据：多个线程共同操作的变量。

        同步监视器：俗称，锁。任何一个类的对象都可以充当锁。

                要求：多个线程必须共用同一锁

        解决了线程安全问题

        只能有一个线程参与，相当于是一个单线程的过程。

/**

* @program: Sword_to_Offer

* @author: GoKu

* @create: 2019-09-24 13:09

*/

public class Person implements Runnable{

    private String name;

    private int ticket = 20;

    public void run(){

        //定义循环执行20次

        while (true){

        synchronized (Person.class){if(ticket > 0){

            try {

                Thread.sleep(100);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + ticket);

            ticket--;

        }else break;

        }

    }

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

    2.同步方法

        同步方法仍然涉及到同步监视器，只是不需要我们显示的声明，非静态的方法监视器是this，静态是类名.class

/**

* @program: Sword_to_Offer

* @author: GoKu

* @create: 2019-09-24 13:09

*/

public class Person implements Runnable{

    private String name;

    private int ticket = 20;

    public synchronized void run(){

       while (true){

           if (ticket >0) show();

           else break;

       }

    }

    private synchronized void show() {

            try {

                Thread.sleep(100);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

            System.out.println(Thread.currentThread().getName() + ticket);

            ticket--;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

线程的死锁

    不同的线程分别占用对方需要的同步资源不放弃，不同的线程都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

    死锁的演示：

/**

* @program: Sword_to_Offer

* @author: GoKu

* 死锁的例子

* @create: 2019-09-25 09:24

*/

public class 死锁 {

    public static void main(String[] args) {

        StringBuffer s1 = new StringBuffer();

        StringBuffer s2 = new StringBuffer();

        new Thread(){

            public void run(){

                synchronized(s1){

                    s1.append('a');

                    s2.append('1');

                    try {

                        Thread.sleep(100);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    synchronized(s2){

                        s1.append('b');

                        s2.append('2');

                        System.out.println(s1);

                        System.out.println(s2);

                    }

                }

            }

        }.start();

        new Thread(new Runnable() {

            @Override

            public void run() {

                synchronized(s2){

                    s1.append('c');

                    s2.append('3');

                    synchronized(s1){

                        s1.append('d');

                        s2.append('4');

                        System.out.println(s1);

                        System.out.println(s2);

                    }

                }

            }

        }).start();

    }

}

Lock(锁)

import java.util.concurrent.locks.ReentrantLock;

/**
 * @program: Sword_to_Offer
 * @author: GoKu
 * 解决线程安全的方式三： Lock 锁
 * @create: 2019-09-25 09:34
 */
public class LockTest {
    static class Window implements Runnable{
        private int ticket = 20;
        //1.实例化lock
        private ReentrantLock lock = new ReentrantLock(true);
        @Override
        public void run() {
            while (true){
                try{
                    lock.lock();
                    if (ticket >0){try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                    System.out.println(Thread.currentThread().getName() + ticket);
                    ticket--;}
                else break;}finally {
                    lock.unlock();
                }

            }
        }
    }

    public static void main(String[] args) {
        Window window = new Window();

        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        t1.setName("旺财");
        t2.setName("狗蛋");
        t1.start();
        t2.start();
    }
}

    synchronized 与 lock有什么不同

        synchroized机制在执行完相应的同步代码以后，自动的释放同步监视器
        lock需要手动启动同步，同时结束同步也需要手动的实现

线程的通信

/**

* @program: Sword_to_Offer

* @author: GoKu

* 线程通信的例子：两个线程交替打印1-100

* @create: 2019-09-25 12:33

*/

class Number implements Runnable{

    private int number = 1;

    @Override

    public void run() {

        while(true){

            synchronized(this){

                notify();

                if(number <= 100){

                System.out.println(Thread.currentThread().getName() + ":" + number);

                number++;

                    try {

                        wait();//释放锁

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                }else break;

        }}

    }

}

public class CommunicationTest {

    public static void main(String[] args) {

        Number number = new Number();

        Thread t1 = new Thread(number);

        Thread t2 = new Thread(number);

        t1.setName("线程1");

        t2.setName("线程2");

        t1.start();

        t2.start();

    }

}

    wait():当前线程进入阻塞状态，并释放同步监视器

    notify():唤醒被wait的一个线程，如果有多个线程被wait，就唤醒优先级高的

    notifyAll():唤醒所有被wait的一个线程

    这三个方法都必须在synchronzied同步代码块里；

    这三个方法的调用者都必须是synchronzied的同步监视器；

    定义在Object类中

sleep（）和wait（）的异同：

    相同点：一旦执行方法，都可以使线程进入阻塞状态

    不同点：1）声明的位置不一样：Thred类声明sleep（），Object类声明wait（）

                    2）调用的要求不同：sleep（）可以在任何场景调用，wait必须在同步代码块

                    3）关于是否释放同步监视器：sleep不释放，wait释放

经典例题：生产者/消费者问题

/**

* @program: Sword_to_Offer

* @author: GoKu

* 线程通信的应用;生产者/消费者问题

* @create: 2019-09-25 12:54

*/

class Clerk{

    private  int productCount = 0;

    public synchronized void produceProduct(){

        if(productCount < 20){

            productCount++;

            System.out.println(Thread.currentThread().getName() + "开始生产第" + productCount + "个产品");

            notify();

        }else{

            //等待

            try {

                wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public synchronized void consumeProduct(){

        if(productCount > 0){

            System.out.println(Thread.currentThread().getName() + "开始消费第" + productCount + "个产品");

            productCount--;

            notify();

        }else{

            //等待

            try {

                wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

class Productor extends Thread{

    private Clerk clerk;

    public Productor(Clerk clerk){

        this.clerk = clerk;

    }





    @Override

    public void run() {

        System.out.println("开始生产");

        while (true){

            clerk.produceProduct();

        }

    }

}

class Customer extends Thread{

    private Clerk clerk;

    public Customer(Clerk clerk){

        this.clerk = clerk;

    }





    @Override

    public void run() {

        System.out.println("开始消费");

        while (true){

            clerk.consumeProduct();

        }

    }

}

public class Prouduct {

    public static void main(String[] args) {

        Clerk clerk = new Clerk();

        Productor p = new Productor(clerk);

        Customer c = new Customer(clerk);

        p.start();

        c.start();

    }

}