java高级之线程

        1. 进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位。
        2. 一个程序运行后至少有一个进程。
        3. 一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义。
        4. 进程间不能共享数据段地址，但是同进程的线程之间可以。

2.线程

2.1 线程的组成

任何一个线程都具有基本的组成部分
CPU时间片: 操作系统（OS）会为每个线程分配执行时间

           运行数据:
                堆空间: 存储线程需要的对象，多个线程可以共享堆中的数据。
                栈空间: 存储线程需使用的局部变量，每个线程都拥有独立的栈。

线程的逻辑代码。

2.2 线程的特点

1. 线程抢占式执行

效率高
可防止单一线程长时间独占CPU

2. 在单核CPU中，宏观上同时执行，微观上顺序执行

2.3 线程的创建方式

        1. 【继承Thread类，重写run方法】
        2. 【实现Runnable接口】
        3. 实现Callable接口

2.3.1 获取和设置线程的名称

1.获取线程ID和线程名称

（1）在Thread的子类中调用this.getId()或this.getName()
（2）使用Thread.currentThread().getId()和Thread.currentThread().getName()

2.修改线程名称

（1）调用线程对象的setName()方法
（2）使用线程子类的构造方法赋值

2.3.2 继承Thread类

方法：

public class ThreadTest extends Thread{
    @Override
    public void run() {
        //写自己的任务代码
        for (int i = 0; i < 20; i++) {
            //1通过Thread对象中getName()；有缺点只能在Thread子类中获取
            //System.out.println(this.getName()+"======================="+i);

            //2在Thread类中存在一个静态方法可以获取当前线程对象，再通过该对象调用getName()
            System.out.println(Thread.currentThread().getName()+"==============="+i);
        }
    }
}

测试类：

public class MainTest {
    public static void main(String[] args) {
        //创建一个线程对象
        ThreadTest threadTest=new ThreadTest();

        threadTest.setName("副线程");//设置线程名称
        //开启线程---执行时会调用run方法 时间片
        threadTest.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程----------------"+i);
        }
    }
}

2.3.3 实现Runnable接口

任务代码：

public class MyRunnable implements Runnable {
    //任务代码
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"============"+i);
        }
    }
}

测试类：

public class RunnableTest {
    public static void main(String[] args) {
        //1.创建任务对象
        MyRunnable myRunnable=new MyRunnable();
        //2.创建线程对象并执行要执行的任务 可直接命名 myRunnable此处必写上边对应的创建任务对象名字
        Thread t1=new Thread(myRunnable,"副线程");
        t1.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main线程---------------------"+i);
        }
    }
}

2.4 线程的状态

2.5 常见方法

2.5.1 休眠（sleep）

public static void sleep(long millis)
当前线程主动休眠millis毫秒。

例子：实现一个时间显示，每隔一秒钟更新一次显示。例如时间秒数显示

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

        DateFormat date=new SimpleDateFormat("yyyy-MM-dd E HH:mm:ss");//自定义时间模式

        while (true){
            Date d=new Date();//获取当前时间
            String format = date.format(d);
            System.out.println(format);
            try {
                Thread.sleep(1000);//当前线程主动休眠1秒进行打印 此处有异常要抛出
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

2.5.2 放弃（yield）

public static void yield()
当前线程主动放弃时间片，回到就绪状态，竞争下一次时间片线程；调用yield会让出cpu的执行权，但别的线程不一定接受礼让。在cpu比较繁忙的时候效果明显，空闲的时候没什么影响。

例子：A B两个线程，不断对i进行输出，B执行yield方法，B线程的i出现次数频率明显减少。没有yield方法的话，A B两个线程的出现频率次数差不多

public class YieldTest {

    public static void main(String[] args) {
        A a=new A();
        B b=new B();
        a.setName("A");
        b.setName("B");
        a.start();
        b.start();
    }
}
class A extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"======"+i);
        }
    }
}
class B extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            Thread.yield();
            System.out.println(Thread.currentThread().getName()+"============="+i);
        }
    }
}

2.5.3 加入（join）

public final void join()
允许其他线程加入到当前线程中

例子：

在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行

join方法必须在线程start方法调用之后调用才有意义

join方法可以在start方法前调用时，并不能起到同步的作用

开启多条线程同时爬取不同网站的信息，进行处理，然后统一返回给前台，这里面要注意的就是，我们必须等待前面的线程都执行结束，才能返回给前端

public class JoinTest {

    public static void main(String[] args) throws InterruptedException {
        Runnable a=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 4; i++) {
                    System.out.println("A："+i);
                }
            }
        };
        Runnable b=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 4; i++) {
                    System.out.println("B："+i);
                }
            }
        };
        Thread t1=new Thread(a);
        Thread t2=new Thread(b);

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

        t1.join();
        t2.join();
        System.out.println("爬取结束");
    }
}

2.5.4 守护线程（setDaemon）

     线程对象.setDaemon(true);设置为守护线程。
     线程有两类:用户线程（前台线程）和守护线程（后台线程）
     如果程序中所有前台线程都执行完毕了，后台线程也会自动结束。
     垃圾回收线程属于守护线程。

举例：将一个线程以守护线程方式来运行，即主线程已经执行完毕,守护线程程序也结束

public class DaemonTest {
    public static void main(String[] args) throws InterruptedException {
        Daemon d=new Daemon();

        Thread t=new Thread(d);
        t.setDaemon(true);
        t.start();
        Thread.sleep(3000);
        System.out.println("线程结束");

    }
}
class Daemon implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("运行副线程"+i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }
}

2.6 线程的状态

3.线程安全

3.1 线程安全问题

代码展示：

public class Safe {
    private static String [] arr=new String[5];
    private static int index=0;
    public static void main(String[] args) throws Exception {

        //匿名函数
        Runnable hello=new Runnable() {
            @Override
            public void run() {
                if(arr[index]==null){
                    arr[index]="hello";
                    index++;
                }
            }
        };
        //匿名函数
        Runnable world=new Runnable() {
            @Override
            public void run() {
                if(arr[index]==null){
                    arr[index]="world";
                    index++;
                }
            }
        };

        Thread t1=new Thread(hello);
        Thread t2=new Thread(world);
         t1.start();
         t2.start();

         t1.join();
         t2.join();

        System.out.println(Arrays.asList(arr));
        //此处结果有4种
        //[hello, world, null, null, null]
        //[world, hello, null, null, null]
        //[hello, null,  null, null, null]
        //[world, null,  null, null, null]
    }
}

出现问题

（1）当多线程并发访问临界资源时，如果破坏原子操作，可能会造成数据不一致。

（2）临界资源：共享资源（同一对象），一次仅允许一个线程使用，才可保证其正确性。

（3）原子操作：不可分割的多步操作，被视作一个整体，其顺序和步骤不可打乱或缺省。

3.2 解决方法

3.2.1 同步代码块

synchronized(临界资源对象){//临界资源对象加锁

//代码（原子操作）

}

注意：

每个对象都有一个互斥锁标记，用来分配给线程

只有拥有对象互斥锁标记的线程，才能进入对该对象加锁的同步代码块

线程退出同步代码块时，会释放相应的互斥锁标记

举例1：四个窗口分别卖100张票

public class Buy extends Thread{
    private static int ticked=100;
    @Override
    public void run() {
        while (true){
            if(ticked>0){
                System.out.println(this.getName()+"正在卖第"+ticked+"张票");
                ticked--;
            }else{
                break;
            }
        }

    }
}

测试类

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

        Buy buy1=new Buy();
        buy1.setName("窗口1");
        Buy buy2=new Buy();
        buy2.setName("窗口2");
        Buy buy3=new Buy();
        buy3.setName("窗口3");
        Buy buy4=new Buy();
        buy4.setName("窗口4");
        buy1.start();
        buy2.start();
        buy3.start();
        buy4.start();
    }
}

可能会出现负数，多线程共享一个资源时就有可能出现线程安全问题

举例2：四个窗口共卖100张票

（1）使用Runable

public class BuyOnly implements Runnable{
    private static int ticked=100;
    @Override
    public void run() {
        while (true){
            synchronized (this){//必须保证多个线程使用的是同一个锁，此处不能new一个对象,ticked不是一个对象
                if(ticked>0){
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticked+"张票");
                    ticked--;
                    try{
                        Thread.currentThread().sleep(100);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }

        }
    }
}

测试类

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

        BuyOnly buyOnly=new BuyOnly();

        Thread thread=new Thread(buyOnly,"窗口A");
        Thread thread1=new Thread(buyOnly,"窗口B");
        Thread thread2=new Thread(buyOnly,"窗口C");
        Thread thread3=new Thread(buyOnly,"窗口D");

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

（2）使用Thread

public class BuyOnlyThread extends Thread{
    private static int ticked=100;
    @Override
    public void run() {
        while(true){
            //使用本类作为锁对象
            synchronized (BuyOnlyThread.class){
                if(ticked>0){
                    try{
                        Thread.sleep(10);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(this.getName()+"正在卖第"+ticked+"张票");
                    ticked--;
                }else{
                    break;
                }

            }
        }
    }
}

测试类

public class BuyOnlyThreadTest {
    public static void main(String[] args) {
        BuyOnlyThread buyOnlyThread=new BuyOnlyThread();
        buyOnlyThread.setName("A窗口");
        BuyOnlyThread buyOnlyThread1=new BuyOnlyThread();
        buyOnlyThread1.setName("B窗口");
        BuyOnlyThread buyOnlyThread2=new BuyOnlyThread();
        buyOnlyThread2.setName("C窗口");
        BuyOnlyThread buyOnlyThread3=new BuyOnlyThread();
        buyOnlyThread3.setName("D窗口");

        buyOnlyThread.start();
        buyOnlyThread1.start();
        buyOnlyThread2.start();
        buyOnlyThread3.start();
    }
}

3.2.2 线程的等待

3.2.3 同步方法

synchronized 返回值类型方法名称（形参列表）{//对当前对象（this）加锁

//代码（原子操作）

}

注意：

只有拥有对象互斥锁的标记的线程，才能进入该对象加锁的同步方法中

线程退出同步方法时，会释放相应的互斥锁标记

4.死锁

死锁：当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁

一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁

出现原因：锁的嵌套

举例：吃饭时需要一双筷子，现在有两人一人分一根筷子，如何完成吃饭

定义锁的类型

public class LockObject {
    public static Object a=new Object();
    public static Object b=new Object();
}

定义Boy,Girl类

public class Boy extends Thread{
    @Override
    public void run() {
        synchronized (LockObject.a){
            System.out.println(Thread.currentThread().getName()+"获取一根筷子a");
            synchronized (LockObject.b){
                System.out.println(Thread.currentThread().getName()+"获取一根筷子b");
                System.out.println("可以吃饭了");
            }
        }
    }
}

public class Girl extends Thread{
    @Override
    public void run() {
        synchronized (LockObject.b){
            System.out.println(Thread.currentThread().getName()+"获取一根筷子b");
            synchronized (LockObject.a){
                System.out.println(Thread.currentThread().getName()+"获取一根筷子a");
                System.out.println("可以吃饭了");
            }
        }
    }
}

定义测试类

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

        Boy b=new Boy();
        Girl g=new Girl();

        b.setName("Tom");
        g.setName("Marry");

        b.start();
        g.start();
    }
}

5.线程通信

两者都不是在Thread类中，而是在Object类中

等待：

public final void wait()

public final void wait(long timeout)

必须在对obj加锁的同步代码块中。在一个线程中，调用obj.wait()时，此线程会释放其拥有的所有锁标记。同时此线程阻塞在o的等待队列中。释放锁，进入等待队列。

通知：

public final void notify()

public final void notifyAll()

唤醒等待队列中线程，进入就绪队列，参与CPU的竞争

举例：男友存钱，女友取钱问题，必须先存才可以取钱

银行卡类

public class BankCard {
    private double balance;
    //false代表没有钱  true代表有钱
     private boolean flag=false;

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
    //存钱
    public synchronized void save(double money){
        if(flag==true){
            //进入等待队列
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //进入存钱
        this.balance=this.balance+money;
        System.out.println(Thread.currentThread().getName()+"存入"+money+",余额为："+this.balance);
        flag=true;
        //唤醒等待队列的线程
        this.notify();
    }
    //取钱
    public synchronized void take(double money){

        if(flag==false){
            //进入等待队列
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //进入取钱
        this.balance=this.balance-money;
        System.out.println(Thread.currentThread().getName()+"取出"+money+",余额为："+this.balance);
        flag=false;
        //唤醒等待队列的线程
        this.notify();
    }
}

定义男，女主

public class Boy extends Thread{
    private BankCard bankCard;

    public Boy(BankCard bankCard){
        this.bankCard=bankCard;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            bankCard.save(1000);
        }
    }
}

public class Girl extends Thread{
    private BankCard bankCard;

    public Girl(BankCard bankCard){
        this.bankCard=bankCard;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            bankCard.take(1000);
        }
    }
}

定义测试类

public class MoneyTest {
    public static void main(String[] args) {
        BankCard bankCard=new BankCard();
        Boy b=new Boy(bankCard);
        Girl g=new Girl(bankCard);
        b.setName("Tom");
        g.setName("Marry");
        b.start();
        g.start();
    }
}

6.线程池

6.1 何为线程池

出现的问题：

（1）线程是宝贵的内存资源、单个线程约占1MB空间，过多分配易造成内存溢出。

（2）频繁的创建及销毁线程会增加虚拟机回收频率、资源开销，造成程序性能下降。

线程池：

（1）线程容器，可设定线程分配的数量上限。

（2）将预先创建的线程对象存入池中，并重用线程池中的线程对象。

（3）避免频繁的创建和销毁。

6.2 常用方法

Executor:线程池的根类。里面有一个方法。execute执行线程任务的方法Runnable类型的任务

ExecutorService：线程池的子接口

shutdown():关闭线程池。需要等待线程池中任务执行完毕后才会关闭

shutdownNow():立即关闭线程池

isTerminated():判断线程池是否终止了

submit():提交任务给线程池中线程对象。Runable和Callable类型的任务

6.3 线程池方法的使用

public class CreatMethods {
    public static void main(String[] args) {
        //单一线程池 使用场景：队列要求线程有序执行
        //ExecutorService executorService = Executors.newSingleThreadExecutor();

        //创建固定长度的线程池对象
        //ExecutorService executorService = Executors.newFixedThreadPool(3);

        //创建可变长度的线程池 不会根据i输出数字一致，如果是100可能就会创建40多个
        //ExecutorService executorService = Executors.newCachedThreadPool();

        //创建延迟线程池对象
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
//前三个方法使用
//        for (int i = 0; i < 5; i++) {
//            executorService.submit(new Runnable() {
//                @Override
//                public void run() {
//                    System.out.println(Thread.currentThread().getName()+"=========================");
//                }
//            });
        for (int i = 0; i < 100; i++) {
            executorService.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"=========================");
                }
            },10, TimeUnit.SECONDS);
        }
        executorService.shutdown();
    }
}

6.4 通过自定义阻塞队列创建线程池

上面讲解的使用Executors创建线程池的方式，都是使用底层ThreadPoolExecutor，而阿里开发手册，建议使用最原始的方式。

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

*  int corePoolSize,核心线程数
*  int maximumPoolSize,最大线程数
*  long keepAliveTime,空闲时间
*  TimeUnit unit,时间单位
*  BlockingQueue<Runnable> workQueue 堵塞队列

public class CreatMethodsTest {
    public static void main(String[] args) {
        //LinkedBlockingDeque:可以设置等待的个数，如果不设置默认为Integer的最大值
        BlockingQueue blockingQueue=new LinkedBlockingDeque(3);
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(2,5,10, TimeUnit.SECONDS,blockingQueue);
        for (int i = 0; i < 5; i++) {
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"---------");
                }
            });
        }
        threadPoolExecutor.shutdown();
    }
}

7.创建线程的第三种方式

实现Callable接口，它和实现Runnable接口差不多，只是该接口种的方法有返回值和异常抛出。比较适用于大文件的上传。

举例：进行1-100的值相加

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //自创建线程对象并提交Callable类型的任务是比较麻烦的，需要封装到一个FutureTask类种
        //比较麻烦，建议使用线程池
//        My task=new My();
//        FutureTask futureTask=new FutureTask(task);
//        Thread t1=new Thread(futureTask);
//        t1.start();
//        System.out.println(futureTask.get());

        My t=new My();
        My2 t2=new My2();

        ExecutorService executorService = Executors.newFixedThreadPool(5);

        Future<Integer> submit = executorService.submit(t);
        Future<Integer> submit2 = executorService.submit(t2);

        Integer integer = submit.get();//需要等待线程执行完毕后，才会把结果返回该变量
        Integer integer2 = submit2.get();//需要等待线程执行完毕后，才会把结果返回该变量

        System.out.println(integer+integer2);
        executorService.shutdown();
    }
}
class My implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for (int i = 0; i <=100; i++) {
            sum+=i;
        }
        return sum;
    }
}
class My2 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum2=0;
        for (int i = 0; i <=100; i++) {
            sum2+=i;
        }
        return sum2;
    }
}

8.手动锁

举例：四个窗口买票

8.1 Thread方法手动锁

public class LockTest {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        TicketTest ticketTest=new TicketTest();
        ticketTest.setMyLock(lock);//注意此处的锁，每new一次都会有一把新锁，要使用同一把锁
        ticketTest.setName("窗口A");
        TicketTest ticketTest1=new TicketTest();
        ticketTest1.setMyLock(lock);
        ticketTest1.setName("窗口B");
//        TicketTest ticketTest2=new TicketTest();
//        ticketTest2.setName("窗口C");
//        TicketTest ticketTest3=new TicketTest();
//        ticketTest3.setName("窗口D");

        ticketTest.start();
        ticketTest1.start();
//        ticketTest2.start();
//        ticketTest3.start();
    }
}
class TicketTest extends Thread{
    private static int ticket=100;
    //定义手动锁
    Lock myLock;

    public Lock getMyLock() {
        return myLock;
    }

    public void setMyLock(Lock myLock) {
        this.myLock = myLock;
    }

    @Override
    public void run() {

        try{myLock.lock();//上锁
            while (true){
                    if(ticket>0){
                        System.out.println(Thread.currentThread().getName()+"正在卖第"+--ticket+"张");
                    }else {
                        break;
                    }
                }

            }finally {
            myLock.unlock();//开锁
         }
    }
}

8.2 Runnable方法手动锁

public class RunnableLock {
    public static void main(String[] args) {
        RunnableTest runnableTest=new RunnableTest();

        Thread t1=new Thread(runnableTest,"窗口A");
        Thread t2=new Thread(runnableTest,"窗口B");
        Thread t3=new Thread(runnableTest,"窗口C");
        Thread t4=new Thread(runnableTest,"窗口D");
        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}
class RunnableTest implements Runnable{

    private static int ticket=100;

    Lock myLock=new ReentrantLock();
    @Override
    public void run() {
            while(true){
              try{
                // myLock.lock();//要是放在while(true)上边，相当于对整个while锁住，只能有一个窗口进入
                  //boolean b=myLock.tryLock();//查看是否获取锁资源
                myLock.lock();
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket--+"张票");
                }else {
                    System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
                    break;
                }
            }finally {
             myLock.unlock();
           }
        }
    }
}

青柠果

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
java高级之线程

上面讲解的使用Executors创建线程池的方式，都是使用底层ThreadPoolExecutor，而阿里开发手册，建议使用最原始的方式。线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。*intcorePoolSize,核心线程数*intmaximumPoolSize,最大线程数*longkeepAliveTime,空闲时间。......
复制链接

扫一扫