基本概念：程序、进程、线程
- 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
- 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态想·的过程：有它自身的产生、存在和消亡的过程。——生命周期
如：运行中的QQ，运行中的MP3播放器
程序是静态的，进程是动态的
进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域 - 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
若一个进程同一时间并行执行多个线程，就是支持多线程的
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
一个进程中的多个线程共享相同的内存单元/内存地址空间->它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患(线程同步)。
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()，垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。
并行与并发
- 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
- 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。
使用多线程的优点
背景：
以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
何时需要多线程
- 程序需要同时执行两个或多个任务。（gc）
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
- 需要一些后台运行的程序时。（gc）
线程的创建和启动
方式一：继承Thread类
- 定义子类继承Thread类。
- 子类中重写Thread类中的run方法。
- 创建Thread子类对象，即创建了线程对象。
- 调用线程对象start方法：启动线程，调用run方法。
Thread类的特性：
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
通过该Thread对象的start()方法来启动这个线程，而非直接调用run(）
构造器：
Thread()：创建新的Thread对象
Thread(String threadname)：创建线程并指定线程实例名
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象
注意点：
- 如果自己手动调用run()方法，那么就只是普通方法，没有启动多线程模式。
- run()方法由JVM调用，什么时候调用，执行的过程控制都有操作系统的CPU调度决定。
- 想要启动多线程，必须调用start方法。
- 一个线程对象只能调用一次start()方法启动，如果重复调用了，则将抛出以上的异常“IllegalThreadStateException”。
继承thread类的普通方式
/**
* 创建两个线程，一个输出奇数，一个输出偶数
*/
public class ExtendThreadDemo {
public static void main(String[] args) {
MyThread1 myThread1 = new MyThread1();
//线程起名方式1：在构造方法中super() Thread的值
MyThread2 myThread2 = new MyThread2("thread2");
//线程的起名方式2：在主类初始化完成线程类后调用setName方法
myThread1.setName("thread1");
myThread1.start();
myThread2.start();
}
}
class MyThread1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
class MyThread2 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public MyThread2(String name) {
super(name);
}
}
继承thread类的匿名子类方式(开发常用)：
public class ExtendThreadDemo {
public static void main(String[] args) {
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}.start();
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}.start();
}
}
Thread类的常用方法：
- start()：启动当前线程，调用当前线程的run()
- run()：通常需要重写thread类的此方法，将创建线程要执行的代码声明在此方法中。
- currentThread()：thread类的静态方法，返回当前执行代码的线程。
- getName()：获得当前线程的名字。
- setName: 设置当前线程的名字。
- yield():让出当前cpu的执行权
- join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到b完全执行成功后，线程a才结束阻塞状态。
- stop():该方法已过时，执行该方法强制结束当前线程。
- sleep(long milltime):让当前线程睡眠指定的millitime毫秒，在指定时间内当前线程是阻塞状态。
- isAlive() :判断线程是否存活。
线程的优先级：
- 线程的优先级等级
MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 - 涉及的方法
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级 - 说明：
线程创建时继承父线程的优先级
低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用
方式二：实现Runnable接口
- 定义子类，实现Runnable接口。
- 子类中重写Runnable接口中的run方法。
- 通过Thread类含参构造器创建线程对象。
- 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。
- 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。
public class ImplThreadTicketDemo {
public static void main(String[] args) {
Windows1 w = new Windows1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("window1");
t2.setName("window2");
t3.setName("window3");
t1.start();
t2.start();
t3.start();
}
}
class Windows1 implements Runnable{
//使用实现runnable接口的方式默认共享对象变量。
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.printf("%s在卖票,票数:%d\n",Thread.currentThread().getName(),ticket);
ticket--;
} else {
break;
}
}
}
}
继承方式和实现方式的联系与区别
- 区别
继承Thread：线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法。 - 实现方式的好处
避免了单继承的局限性
多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。 - 联系：
- Thread类本身就实现了Runnable接口
- 相同点：两种方式都要重写run(),将线程要执行的逻辑卸载run方法中。
线程的生命周期
- JDK中用Thread.State类定义了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：- 新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
- 阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
线程的安全问题（同步）
- 实现Runnable方式做到线程安全（同步代码块）：
public class ImplThreadTicketDemo {
public static void main(String[] args) {
/*
* 只new了一个线程对象，线程对象中又只存在一个线程监视器obj
* new了三个线程并将同一个线程对象引用进去，即3个线程共用一把锁（obj）
* */
Windows1 w = new Windows1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("window1");
t2.setName("window2");
t3.setName("window3");
t1.start();
t2.start();
t3.start();
}
}
class Windows1 implements Runnable{
//实现的方式本就天然的实现了数据的共享，因为是new一个线程对象，放到Thread中
//同步监视器(锁)
//Object object = new Object();
//使用实现runnable接口的方式默认共享对象变量。
private int ticket = 100;
@Override
public void run() {
while (true) {
//obj是最初锁,表现方式麻烦
//this表示的是当前对象，使用实现Runnable的方式可以保证当前Windows1唯一，可用this当锁。
//Windows1.class也可充当锁。
synchronized (this) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("%s在卖票,票数:%d\n", Thread.currentThread().getName(), ticket);
ticket--;
} else {
break;
}
}
}
}
}
- 继承Thread方式做到线程安全（同步代码块）：
public class ExtendThreadTicketDemo {
public static void main(String[] args) {
Window t1 = new Window();
Window t2 = new Window();
Window t3 = new Window();
t1.setName("window1");
t2.setName("window2");
t3.setName("window3");
t1.start();
t2.start();
t3.start();
}
}
class Window extends Thread{
//与实现Runnable接口不同，要在共享数据定义为static
//每个实例化对象共享同一个静态变量
private static int ticket = 100;
private static Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) {
if (ticket > 0) {
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("%s:sale ticket,num:%d\n",getName(),ticket);
ticket--;
}else {
break;
}
}
}
}
}
二者区别在于：实现Runnable的方式能做到天然的共享数据隔离，因为只new一次线程对象，二继承的方式是要做几个线程就new几个对象，想实现公用共享数据和同步锁，只能使用static来让实例化出的对象共享静态数据。
- 实现Runnable方式做到线程安全（同步方法）：
public class ImplThreadTicketMethodDemo {
public static void main(String[] args) {
Windows windows = new Windows();
Thread t1 = new Thread(windows);
Thread t2 = new Thread(windows);
Thread t3 = new Thread(windows);
t1.setName("w1");
t2.setName("w2");
t3.setName("w3");
t1.start();
t2.start();
t3.start();
}
}
class Windows implements Runnable{
//创建线程共享数据
private int ticket = 100;
@Override
public void run() {
while (true) {
show();
}
}
/**
* 方法同步 默认的同步锁是this，使用实现Runnable的方式正好可以使用this，
* 因为没有static来限制，又只new一次线程方法
*/
public synchronized void show(){
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("%s在卖票,票数:%d\n", Thread.currentThread().getName(), ticket);
ticket--;
}
}
}
- 继承Thread方式做到线程安全（同步方法）：
public class ExtendThreadTicketMethodDemo {
public static void main(String[] args) {
Windows2 t1 = new Windows2();
t1.setName("window1");
t1.start();
Windows2 t2 = new Windows2();
t2.setName("window2");
t2.start();
Windows2 t3 = new Windows2();
t3.setName("window3");
t3.start();
}
}
class Windows2 extends Thread{
/**
* 继承方式实现多线程必须在共享变量加static，保证此类实例化多个对象共享该静态变量。
*/
private static int ticket=100;
@Override
public void run() {
while (true) {
show();
}
}
//因同步方法的同步监视器默认是this，在以继承实现多线程时new的是多个线程对象即多个this，同步监视器不同，因此线程肯定不安全
//要用同步方法好事，就让同步方法变成静态的，此时同步监视器不是this（因为静态方法中不能调this）而是当前类Windows2；
private static synchronized void show(){
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (ticket > 0) {
System.out.printf("%s在卖票,票数:%d\n", Thread.currentThread().getName(), ticket);
}
ticket--;
}
}
关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只不过默认的，无需显式声明；
2.非静态的同步方法，同步监视器是this
静态的同步方法，同步监视器是当前类本身
- 单例模式的懒汉式线程安全优化：
/**
* 对单例模式的懒汉式进行线程安全的优化
*/
public class SingletoneThread {
public static void main(String[] args) {
}
}
class Bank {
private Bank(){}
public static Bank instance = null;
/**
* 以下方法实现了单例模式的线程安全，但效率略低
* 因为有一个线程进来new出来一个对象然后返回，
* 其他对象就不用再一个个进入到同步代码块进行返回对象操作了
* @return
*/
/*public static Bank getInstance(){
//同步监视器是Bank.class，因为是static，不能调用this作为同步监视器；
synchronized (Bank.class){
if (instance == null) {
instance = new Bank();
}
return instance;
}
}*/
/**
* 笔试手写懒汉式。
*
* 优化后，当第一个线程进来实例化了一个对象，
* 其他线程就不用再进入同步代码块中进行返回操作了，
* 判断实例不为空就直接返回，效率较高。
* @return
*/
public static Bank getInstance(){
if (instance == null) {
synchronized (Bank.class){
if (instance == null) {
instance=new Bank();
}
}
}
return instance;
}
}
线程的死锁问题
-
死锁
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃
自己需要的同步资源，就形成了线程的死锁 - 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于
阻塞状态，无法继续
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃
-
解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
死锁的代码
/**
* 线程死锁的情况
* 死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放自己需要的同步资源，就形成了线程的死锁
* 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
*
*/
public class DeadThread {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
/**
* 两线程的同步锁之间节加sleep是为了让死锁的概率增加
* 死锁释义：
* 程序从Thread匿名线程运行，拿到了同步监视器s1并执行了两个append方法，
* 然后sleep线程休眠，此时cpu时间片交给了Runnable匿名线程，同样的拿到了监视器s2并执行append方法
* sleep线程休眠，此时cpu时间片还给了Thread匿名线程，从休眠开始的地方继续向下运行，但是运行着需要拿同步监视器s2
* 但s2已经被Runnable匿名线程拿到，此时就出现死锁。
* 死锁原因：
* 嵌套同步，并重复获得同步监视器。
*/
new Thread(){
@Override
public void run() {
synchronized(s1){
s1.append("a");
s2.append(1);
//不加sleep出现死锁的概率很小，加上sleep让概率变大
try {
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);
//不加sleep出现死锁的概率很小，加上sleep让概率变大
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
s1.append("d");
s2.append(4);
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
lock锁
- 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。
- ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。
使用lock锁实现线程同步问题
public class LockThread {
public static void main(String[] args) {
LockWindow w = new LockWindow();
Thread t1 = new Thread(w);
t1.setName("1");
t1.start();
Thread t2 = new Thread(w);
t2.setName("2");
t2.start();
Thread t3 = new Thread(w);
t3.setName("3");
t3.start();
}
}
class LockWindow implements Runnable{
private int ticket = 100;
// 参数为fair，是否为公平锁，默认为false
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true){
//在try中声明锁的作用范围
try {
lock.lock();
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.printf("%s saleTicket,num:%d\n",Thread.currentThread().getName(),ticket);
ticket--;
}else {
break;
}
}finally {
lock.unlock();
}
}
}
}
synchronized 与 Lock 的对比
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
优先使用顺序：
Lock -> 同步代码块（已经进入了方法体，分配了相应资源） -> 同步方法（在方法体之外）
释放锁的操作
- 当前线程的同步方法、同步代码块执行结束。
- 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。
不会释放锁的操作
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
- 应尽量避免使用suspend()和resume()来控制线程
多线程练习：
银行有一个账户。
有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
public class ExerBankSaveThread {
public static void main(String[] args) {
Account account = new Account(0);
Customer c1 = new Customer(account);
Customer c2 = new Customer(account);
c1.setName("A");
c2.setName("B");
c1.start();
c2.start();
}
}
class Account{
private double balance;
public Account(double balance){
this.balance = balance;
}
public synchronized void deposit(double accmt){
if (accmt > 0) {
balance+=accmt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":saved,balance:"+balance);
}
}
}
class Customer extends Thread{
private Account acct;
public Customer(Account acct){
this.acct = acct;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
acct.deposit(1000);
}
}
}
线程间通信
wait() 与 notify() 和 notifyAll()
- wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。
- notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
- notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。
这三个方法的调用者必须是同步监视器对象
- wait() 方法：
在当前线程中调用方法： 对象名.wait()
使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify(或notifyAll) 为止。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
调用此方法后，当前线程将释放对象监控权 ，然后进入等待
在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。 - notify()/notifyAll()：
在当前线程中调用方法： 对象名.notify()
功能：唤醒等待该对象监控权的一个/所有线程。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
使用notify和wait实现两个线程交替打印100数：
/**
* 使用notify和wait实现两个线程交替打印100数
*/
public class CommunicationThread {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
t1.setName("thread1");
t1.start();
Thread t2 = new Thread(number);
t2.setName("thread2");
t2.start();
}
}
class Number implements Runnable{
private int number = 1;
@Override
public void run() {
while (true){
synchronized (this) {
//一个线程唤起被wait的线程,如果有多个被wait的线程，唤起的是优先级最高的
this.notify();
if (number <= 100) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+number);
number++;
try {
//使该线程处于阻塞状态，并且让该线程失去同步锁
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
经典例题：生产者/消费者问题
/**
* 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处
* 取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图
* 生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通
* 知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如
* 果店中有产品了再通知消费者来取走产品。
*
* 这里可能出现两个问题：
* 生产者比消费者快时，消费者会漏掉一些数据没有取到。
* 消费者比生产者快时，消费者会取相同的数据。
*/
public class ProductorConsumerThreadCommunication {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Productor p1 = new Productor(clerk);
p1.setName("p1");
p1.start();
Consumer c1 = new Consumer(clerk);
c1.setName("c1");
c1.start();
Consumer c2 = new Consumer(clerk);
c2.setName("c2");
c2.start();
}
}
//店员
class Clerk{
private int product = 0;
//生产产品
public synchronized void produceProduct() {
if (product < 20) {
product++;
System.out.println(Thread.currentThread().getName()+"开始生产第"+product+"个产品");
//生产出一个产品就可以让消费者苏醒进行消费
notify();
} else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//消费产品
public synchronized void consumeProduct() {
if (product > 0) {
System.out.println(Thread.currentThread().getName()+"开始消费第"+product+"个产品");
product--;
//消费完一个就可以让生产者继续生产
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(getName()+":开始生产产品");
while (true) {
try {
sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.produceProduct();
}
}
}
class Consumer extends Thread{
private Clerk clerk;
public Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(getName()+":开始消费产品");
while (true) {
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
面试题：sleep()和wait()的异同：
- 相同点：一旦方法执行，都可使当前线程进入阻塞状态。
- 不同点：
- 两个方法所声明的位置不同；Thread类中声明sleep()，Object类中声明wait()
实现Callable接口创建线程
- 与使用Runnable相比， Callable功能更强大些
- 相比run()方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
/**
* 创建线程的方式三：实现callable接口。 --- jdk5新增
*
* 如何理解callable接口的方式创建线程比实现Runnable接口创建线程方式强大？
* 1、可以有返回值
* 2、可以抛出异常信息，被外面的操作捕获，获取异常信息
* 3、支持泛型
*/
public class CallableThreadReturnOuSum {
public static void main(String[] args) {
//3.创建callable接口的实现类对象
NumberThread numberThread = new NumberThread();
//4.将callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask对象
FutureTask futureTask = new FutureTask(numberThread);
//5.将FeatureTask对象作为参数传递到Thread类的构造器中，创建Thread并调用start方法。
new Thread(futureTask).start();
try {
//6.获取返回值。
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()返回值
Object num = futureTask.get();
System.out.println(num);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
//1.创建一个实现Callable的实现类
class NumberThread implements Callable{
private int sum = 0;
//2.实现call()，将线程需要执行的操作声明在call()
@Override
public Object call() throws Exception {
for (int i = 1; i <= 100 ; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum+=i;
}
}
return sum;
}
}
使用线程池创建线程
- 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
- 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
- 好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime：线程没有任务时最多保持多长时间后会终止
线程池相关API
- JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
- ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
- <T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行Callable
- void shutdown() ：关闭连接池 - Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
/**
* 创建线程方式4:线程池
*/
public class ThreadPool {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(10);
service.execute(new NumThread());
service.execute(new NumThread1());
//submit()参数为callable
//service.submit()
//关闭连接池
service.shutdown();
}
}
class NumThread 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 NumThread1 implements Runnable{
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i%2!=0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
240
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
