Java高级API-多线程

多线程

线程的概念

进程是应用程序的执行实例和有独立的内存空间和系统资源。
线程是CPU调度和分派的基本单位，应用程序的执行实例。
多线程是如果在一个进程中同时运行了多个线程，用来完成不同的工作，多个线程交替占用CPU资源，而非真正的并行执行。
多线程的好处：
1.充分利用CPU的资源
2.简化编程模型
3.带来良好的用户体验

线程的创建和启动

1.主线程：
Thread类：Java提供了java.lang.Thread类支持多线程编程
（1）main()方法即为主线程入口
（2）产生其他子线程的线程
（3）必须最后完成执行，因为它执行各种关闭动作

//显示主线程名
public static void main(String args[]) {
		Thread t= Thread.currentThread(); 
		System.out.println("当前线程是: "+t.getName()); 
		t.setName("MyJavaThread"); 
		System.out.println("当前线程名是: "+t.getName()); 
}

2.线程的创建和启动
在Java中创建线程的两种方式：
（1）继承java.lang.Thread类
（2）继承java.lang.Runnable接口
使用线程的步骤：
（1）定义线程
（2）创建线程对象
（3）启动线程
（4）终止线程
继承Thread类创建线程
（1）定义Testthread类继承Thread类
（2）重写run()方法，编写线程执行体
（3）创建线程对象，调用start()方法启动线程

public class Testthread extends Thread{
    public void run(){//线程工作的主体
        Thread t=Thread.currentThread();
        for (int i = 0; i <10 ; i++) {
            System.out.println(t.getName()+"：第"+(i+1)+"次执行");
        }
    }

public static void main(String[] args) {
        Testthread t=new Testthread();
        t.start();//启动线程
}

多个线程交替执行，不是真正的”并行“，线程每次执行时长由分配的CPU时间片长度决定。
启动线程调用run()方法是只有主线程一条执行路径，调用start()是多条执行路径，主要执行路径，主线程和子线程并行交替执行。

public class Testthread extends Thread{
    public void run(){//线程工作的主体
        Thread t=Thread.currentThread();
        for (int i = 0; i <10 ; i++) {
            System.out.println(t.getName()+"：第"+(i+1)+"次执行");
        }
    }
public static void main(String[] args) {
        Testthread t=new Testthread();
        Testthread t2=new Testthread();
        Thread th1=new Thread(t,"子线程1");
        Thread th2=new Thread(t,"子线程2");
//        t.setName("线程1");
//        t2.setName("线程2");
//        t.run();
//        t2.run();
        th1.start();
        th2.start();//使用start方法才是真正意义上的java多线程
    }
}

实现Runnable接口创建线程
（1）定义TestRunnable类实现Runnable接口
（2）实现run()方法，编写线程执行体
（3）创建线程对象，调用start()方法启动线程

public class TestRunnable implements Runnable{
    @Override
    public void run() {
        Thread t=Thread.currentThread();
        for (int i = 0; i < 10; i++) {
            System.out.println(t.getName()+"：第"+(i+1)+"次执行");
        }
    }

    public static void main(String[] args) throws InterruptedException{
        TestRunnable tr=new TestRunnable();
        Thread t1=new Thread(tr,"接口线程1");
        Thread t2=new Thread(tr,"接口线程2");
        t1.start();
        t2.start();
    }
}

继承Thread类：编写简单，可直接操作线程，适用于单继承
实现Runnable接口：避免单继承局限性，便于共享资源

线程的状态

线程(继承Thread或实现接口)–>创建对象(线程的创建)
–>调用start()方法(进入就绪状态)–>调用到run()方法(进入运行状态)
–>多个资源抢占，没抢到的线程(进入阻塞状态),再回到就绪状态
–>类似于发生异常的情况，如果没有处理，则完全死亡
–>如果处理了，则原线程阻塞，其他线程继续抢占资源
–>主方法运行完成的时候，结束、进入死亡状态

线程调度

线程调度指按照特定机制为多个线程分配CPU的使用权

方法	说明
void setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠
void join()	等待该线程终止
static void yield()	暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程
boolean isAlive()	测试线程是否处于活动状态

线程优先级

线程优先级由1~10表示，1最低，默认优先级为5
优先级高的线程获得CPU资源的概率较大

Thread t1=new Thread(tr,"接口线程1");
Thread t2=new Thread(tr,"接口线程2");
t1.setPriority(1);//最低优先级
t2.setPriority(10);//最高优先级

线程休眠

让线程暂时睡眠指定时长，线程进入阻塞状态
睡眠时间过后线程会再进入可运行状态

try {
      Thread.sleep(1000);
	} catch (InterruptedException e) {
      e.printStackTrace();
}

线程的强制运行

使当前线程暂停执行，等待其他线程结束后再继续执行本线程

        for (int i = 0; i <=10 ; i++) {       
        System.out.println(Thread.currentThread().getName()+"：第"+(i+1)+"次执行");
            if (i%3==0){
                t1.join(10);//如果join的线程join前一直是阻塞状态，则等待参数里的毫秒数
            }
        }

线程的礼让

暂停当前线程，允许其他具有相同优先级的线程获得运行机会，该线程处于就绪状态，不转为阻塞状态，只是提供一种可能，但是不能保证一定会实现礼让。

for (int i = 0; i < 10; i++) {
            System.out.println(t.getName()+"：第"+(i+1)+"次执行");
            if (i%3==0){
                Thread.yield();
}

多线程共享数据引发的安全问题

1.使用synchronized修饰的方法控制对类成员变量的访问
2.使用synchronized关键字修饰的代码块
多个并发线程访问同一资源的同步代码块时
（1）同一时刻只能有一个线程进入synchronized(this)同步代码块
（2）当一个线程访问一个synchronized(this)同步代码块时，其他synchronized(this)同步代码块同样被锁定
（3）当一个线程访问一个synchronized(this)同步代码块时，其他线程可以访问该资源的非synchronized(this)同步代码

public class BuyTicket extends Thread{
    public int left=10;//余票
    public int used=0;//使用过的

    @Override
    public void run() {
        while (true) {
//            buy();
            if (left<=0) break;
            synchronized (this){
                if (left<=0) return;
                //购票，余票数-1，已买+1
                left--;
                used++;
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.print("恭喜"+Thread.currentThread().getName()+"成功购票！");
                System.out.println("当前已卖"+used+"，余票数："+left);
            }
        }
    }

    public synchronized void buy(){
        Vector v=new Vector();
        if (left<=0) return;
        //购票，余票数-1，已买+1
            left--;
            used++;
        try {
            Thread.sleep(100);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.print("恭喜"+Thread.currentThread().getName()+"成功购票！");
            System.out.println("当前已卖"+used+"，余票数："+left);
    }

    public static void main(String[] args) {
        BuyTicket bt=new BuyTicket();
        Thread t1=new Thread(bt,"桃跑跑");
        Thread t2=new Thread(bt,"张票票");
        Thread t3=new Thread(bt,"黄牛党");
        t1.start();
        t2.start();
        t3.start();
    }
}

线程安全的类型

ArrayList为非线程安全的类型

类型	方法是否同步	效率比较	适合场景
线程安全	是	低	多线程并发共享资源
非线程安全	否	高	高

常见类型对比
Hashtable：
（1）继承关系：实现了Map接口，Hashtable继承Dictionary类
（2）线程安全，效率较低
（3）键和值都不允许为null
HashMap：
（1）继承关系：实现了Map接口，继承AbstractMap类
（2）非线程安全，效率较高
（3）键和值都允许为null
SringBuffer：线程安全
StringBuilder：非线程安全
concurrent并发包：
java.util.concurrent提供了一系列方便并发编程的类
阻塞队列BlockingQueue
延迟队列DelayQueue
闭锁CountDownLatch
线程池ExecutorService
第三种创建线程的方式
Callable：能够获取线程执行结果