Java基础知识复盘-多线程

一、Java基础知识复盘-多线程

1.1.线程的创建和使用

方式一:继承Thread类

  • 创建一个类继承于Thread
  • 重写Thread类的run方法
  • 创建继承Thread类的子类对象
  • 通过子类对象调用start()方法
public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
        for (int i = 0; i < 1000; i++) {
            if (i % 2 == 0) {
                System.out.println("我是主线程,求偶数:" + i);
            }
        }
    }
}

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            if (i % 2 != 0) {
                System.out.println("我是子线程,求奇数:" + i);
            }
        }
    }
}

方式二:实现Runnable接口

  • 创建一个实现了Runnable接口的类。
  • 实现接口中定义的run()抽象方法。
  • 创建一个实现类的对象。
  • 将实现类的对象通过参数的形式传递到Thread的构造方法中,以此来创建Thread对象。
  • 通过Thread对象来调用start()方法。
public class RunnableTest {
    public static void main(String[] args) {
        MyRunnableThread myRunnableThread = new MyRunnableThread();
        Thread thread = new Thread(myRunnableThread);
        thread.start();
    }
}

class MyRunnableThread implements Runnable {
    @Override
    public void run() {
        Thread.currentThread().setName("子线程");
        for (int i = 0; i < 1000; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}

方式三:实现Callable接口

  • 创建一个实现类Callable接口的实现类。
  • 重写call()方法。
  • 创建实现类的对象。
  • 将实现callable接口的实现类对象作为参数传递到FutureTask的构造函数中。
  • 创建一个Thread对象,并将FutureTask对象作为参数传递,并调用start()方法。
  • 如果需要获取线程的返回值,就使用get()方法调用。
public class CallableTest {
    public static void main(String[] args) {
        CallableThread callableThread = new CallableThread();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callableThread);
        new Thread(futureTask).start();
        try {
            Integer sum = futureTask.get();
            System.out.println(sum);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

对比方式二,有什么不同

  • 相比run()方法,可以有返回值。
  • 这个方法可以抛出异常,实现Runnable接口的run方法只能try-catch
  • 支持泛型的返回值。
  • 可以借助FutureTask类,获取返回结果等操作。

方式四:使用线程池

  • 提供指定线程数量的线程池
  • 执行指定的线程操作,需要提供实现类Runnable接口或者Callable接口的实现类对象
public class ThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        Future submit = executorService.submit(new MyThreadPool());
    }
}

class MyThreadPool implements Callable {

    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            sum += i;
        }
        return sum;
    }
}

说明:

ExecutorService是真正的线程池接口,常见的子类有ThreadPoolExcutor

Executors是一个工具类,用于创建不同的线程池,如下

  • Executors.newCachedThreadPool();:创建一个可根据需要创建新线程的线程池。主要问题是线程数最大数是Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至OOM。
  • Executors.newFixedThreadPool(10);:创建一个可重用固定线程数的线程池。 主要问题是堆积的请求处理队列可能会耗费非常大的内存,甚至OOM。
  • Executors.newSingleThreadExecutor();:创建一个只有一个线程的线程池。 主要问题是堆积的请求处理队列可能会耗费非常大的内存,甚至OOM。
  • Executors.newScheduledThreadPool(10);:创建一个线程池,可以在定期执行。主要问题是线程数最大数是Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至OOM。

尴尬的是,线程池不建议使用Executors去创建,而是通过ThreadPoolExecutor的方式。如下所示:

public class ThreadPoolFactoryTest {
    private static ThreadFactory myThreadFactory = new ThreadFactoryBuilder().setNameFormat("Mythread-pool-%d").build();

    private static ThreadPoolExecutor myThreadPool = new ThreadPoolExecutor(10, 30, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>(), myThreadFactory);

    public static void main(String[] args) {
        myThreadPool.execute(new MyThread2());
    }
}

class MyThread2 implements Runnable {

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

Thread类的常用方法

  • start():启动当前线程,并调用run()方法。
  • Thread.currentThread():得到当前线程。
  • Thread.currentThread().getName();:得到当前线程名称。
  • Thread.currentThread().setName("");:给当前线程设置名称。
  • yield();:释放当前CPU执行权,也可能释放后又被自己抢到。
  • join():就是在线程A中调用线程B的join()方法,就是线程A进入阻塞 状态,等线程B 全结束后再继续执行。
  • sleep(2000):当前线程睡眠时间。也就是阻塞指定时间。
  • isAlive():判断当前线程是否处于存活状态。
  • setPriority(Thread.MAX_PRIORITY);:设置线程的优先级,优先级高只是说优先概念执行,并不是一定比优先级低的先执行。高优先级的线程比低优先级线程抢得CPU的概率要高一点。

1.2.线程的生命周期

线程的生命周期状态定义在Thread.State枚举类中,NEWRUNNABLEBLOCKEDWAITINGTIMED_WAITING``TERMINATED。简单的将一个线程的状态有:新建、就绪、运行、阻塞和死亡五种状态。

生命周期图解

10417188-dd8c9199d521d2d7.png
image-20190402234652085

1.3.线程的同步

线程的同步就是为类解决线程安全问题,线程安全问题就是程序在单线程和多线程分别执行后,结果不一样。这就出现了线程不安全。

synchronized关键字

使用synchronized关键字,同步代码块,将操作共享数据的代码放在同步代码块中,共享数据就是指多个线程共同操作的变量。同步监视器就是锁,任何一个类的对象都可以充当锁,要求多个线程共用同一把锁。语法如下:

synchronized (同步监视器){

}
public class ThreadState {
    public static void main(String[] args) {
        TicketThread ticketThread1 = new TicketThread();
        Thread thread1 = new Thread(ticketThread1);
        thread1.setName("窗口一");
        thread1.start();
        Thread thread2 = new Thread(ticketThread1);
        thread2.setName("窗口二");
        thread2.start();
        Thread thread3 = new Thread(ticketThread1);
        thread3.setName("窗口三");
        thread3.start();
    }
}

class TicketThread implements Runnable {

    private int ticket = 100;

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

1.4.线程的通信

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值