java多线程

创建线程的两种方式

继承Thread类

1创建一个继承于Thread类的子类

2.重写Thread类的run方法（） --> 将此线程执行的操作声明在run()方法中

3.创建Thread类的子类的对象

4.通过此对象调用start()

案例：多窗口售票（暂不考虑线程安全）

//1.创建一个继承于Thread类的子类
class Window extends Thread{

    private static int ticket = 100;
    //2.重写Thread类的run方法（）
    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(getName() + " : 卖票，票号为： " + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        //4.通过此对象调用start():启动当前线程；调用当前线程的run()方法
        t1.start();
        t2.start();
        t3.start();
    }
}    

实现Runnable接口

1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable中的抽象方法： run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()

案例：多窗口售票（暂不考虑线程安全）

//1.创建一个实现了Runnable接口的类
class Window1 implements Runnable{
    private int ticket = 100;
    //2.实现类去实现Runnable中的抽象方法： run()
    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + " : 卖票，票号为： " + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        Window1 w = new Window1();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        //5.通过Thread类的对象调用start():启动线程；调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();
        t2.start();
        t3.start();
    }
}

两种方法的比较

* 开发中：优先选择：实现Runnable接口的方式
* 原因：1.实现的方法没有类的单继承的局限性
* 2.实现的方式更适合来处理多个线程有共享数据的情况
* 联系：public class Thread implements Runnable
* 相同点：两种方法都需要重写run(),将线程要执行的逻辑声明在run()中

 线程的生命周期

 

 

 

线程同步

问题：在卖票过程中，出现了重票，错票---->出现了线程安全问题。

原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

解决方法：当一个线程A在操作ticket的时候，其他线程不能参与进来。直到线程A操作完ticket时，其他线程才可以参与进来。即使线程A出现了阻塞也不能被改变，举个例子，当你上厕所上到一半时，睡着了，其他人也要等你醒来把厕所上完出来，才可以进去上厕所。

在Java中，我们通过同步机制，来解决线程安全问题。

方式一：同步代码块

synchronized(同步监视器){
        //需要被同步的代码
}

说明：1.操作共享数据的代码，即为需要被同步的代码---->不能包含代码多了，也不能包含代码少了。

　　　2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。

　　　3.同步监视器, 俗称：锁。任何一个类的对象，都可以充当锁,但必须是唯一的。

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

　　　补充：在实现Runnable接口创建多线程的方法中，我们可以考虑使用this充当同步监视器。

　　　　　　在继承Thread类创建多线程的方式中，慎用this充当同步监视器。可以考虑当前类来充当同步监视器。

同步代码块处理实现Runnable的线程安全问题

class Window1 implements Runnable{
    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {
        while (true){
            synchronized (obj){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName() + " : 卖票，票号为： " + ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

同步代码块处理继承Thread类的线程安全问题。

class Window extends Thread{

    private static int ticket = 100;
    //继承方式注意加static,将obj更换为Window.class类对象也可以
    private static Object obj = new Object();

    @Override
    public void run() {
        while (true){
            //synchronized (Window.class)
            synchronized (obj){
                if(ticket > 0){
                    System.out.println(getName() + " : 卖票，票号为： " + ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

方法二：同步方法

同步方法处理实现Runnable的线程安全问题

class Window1 implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {
        while (true){
            show();
        }
    }
    private synchronized void show(){//同步监视器：this
        if(ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " : 卖票，票号为： " + ticket);
            ticket--;
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

使用同步方法处理继承Thread类的线程安全问题

class Window extends Thread{

    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            show();
        }
    }
    private static synchronized void show(){
//    private synchronized void show(){//同步监视器：t1,t2,t3,此种解决方式是错误的
            if(ticket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " : 卖票，票号为： " + ticket);
                ticket--;
            }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

关于同步方法的总结：

1.同步方法仍然涉及到同步监视器，只是不需要我们显视的的声明；

2.非静态的同步方法，同步监视器是：this

　静态的同步方法，同步监视器是：当前类本身

同步的方式，解决了线程的安全问题。操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

创建线程的方法三，四

jdk5.0新增两种创建线程的方式

实现Callable接口

与使用Runnable相比，Callable功能更加强大

1.call()相比run()方法，可以有返回值

2.call()方法可以抛出异常,被外面的操作捕获，获取异常的信息。

3.支持泛型的返回值

4.需要借助FutureTask类，比如获取返回结果

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @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 += i;
            }
        }
        return sum;
    }
}

public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并start()调用。
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值。
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

使用线程池

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

提高响应速度（减少了创建新线程的时间），降低资源笑话（重复利用线程池中线程，不需要每次都创建）

便于线程管理：

　　　corePoolSize: 核心池的大小

　　　maximumPoolSize: 最大线程池

　　　keepAliveTime: 线程没有任务时最多保持多长时间后会终止　

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

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0; i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": "+ i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0; i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": "+ i);
            }
        }
    }
}
public class ThreadPool {

    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();

        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable;
        service.execute(new NumberThread1());
//        service.submit(Callable callable);//适合使用于Callable;
        //3.关闭连接池
        service.shutdown();
    }
}