线程
要说线程,我们就需要先明白下面这几个概念
线程和进程:
进程:一个应用程序就是一个或多个进程
线程:一个进程有一个或多个线程。
多线程:
好处:发挥多核cpu的效率(线程不能独立,其依附于进程)
- 并发和并行
并发:(必须是多核cpu才可以达到):一个或多个事件(任务)在同一个时间点(同时执行)
调度方式
抢占调度:给每个任务分配的时间不等
分时调度:给每个任务分配的时间是均等的
(java虚拟机默认使用的是抢占调度)
线程
一个Thread类对象就是一个线程
Thread类
构造方法:
public Thread();
public Thread(String name);
public Thread(Runnable target);
public Thread(Runnable target,String name);
成员变量:
private Runnable target;
静态方法:
static Thread currentThread();
成员方法:
void start();
启动线程后,会执行run方法中的代码
void run(){
if(target!==null){
target.run();
}
};
String getName();
void steName(String name);
Runnable接口
public abstract void run();
Runnable接口的方式和继承Thread类的方式:建议使用Runnable方式
- 线程和任务分离,解耦合,提高代码的健壮性。
- 避免了java单继承的局限性
- 线程池里面,只能传入Runnable或者Callable类型对象,不用new Thread对象
每一个线程启动后都会有一个栈,各自在各自的栈中执行任务。
线程的开销比一般的对象开销要大
多个线程执行时,谁线程执行不确定,谁执行多长时间不确定*
例子:(继承Thread类的方式)
SubThread类
public class SubThread extends Thread{
@Override
public void run() {
//获取当前线程,执行当前线程代码
Thread t = Thread.currentThread();
//获取当前线程的名字
String name = t.getName();
for (int i = 0; i < 10; i++) {
System.out.println(name+" "+i);
}
}
test测试类
public class test2 {
public static void main(String[] args) {
Thread t = new SubThread();
t.start();
Thread m = Thread.currentThread();
String name = m.getName();
for (int i = 0; i < 10; i++) {
System.out.println(name+" "+i);
}
}
}
输出:
main 0
Thread-0 0
main 1
main 2
main 3
main 4
main 5
Thread-0 1
main 6
Thread-0 2
main 7
main 8
main 9
(部分输出)
Runnable方式
public static void main(String[] args) {
//创建一个Runnable类型的对象
Runnable r =new Runnable() {
@Override
public void run() {
Thread a = Thread.currentThread();
String name = a.getName();
System.out.println(name);
}
};
//把Runnable类型对象,赋值给Thread类的成员变量target,并给线程起名为“线程1”
Thread t = new Thread(r,"线程1");
t.start();
}
这个例子也可以用lambda表达式来写
public static void main(String[] args) {
Runnable r = () -> {
System.out.println(Thread.currentThread().getName());
};
new Thread(r,"线程1").start();
}
线程安全
在多个资源访问同一个资源(数据)时会产生线程安全问题
整个操作不是原子操作
例子:
static int m = 0;
public static void main(String[] args) throws InterruptedException {
//创建一个Runnable类型的对象
Runnable r = () -> {
for (int i = 0; i < 10000; i++) {
m++;
}
};
//把Runnable类型对象,赋值给Thread类的成员变量target,并给线程起名为“线程1”
new Thread(r).start();
new Thread(r).start();
Thread.sleep(300);
System.out.println(m);
}
输出:14626
解决办法
1.使用synchronized代码块
语法:
synchronized(锁对象){
//有可能发生线程安全问题的代码
}
2.使用synchronized方法
3.使用lock锁
例子:
synchronized代码块
static int m = 0;
public static void main(String[] args) throws InterruptedException {
//创建一个Runnable类型的对象
Runnable r = new Runnable() {
@Override
public void run() {
synchronized (this){
for (int i = 0; i < 10000; i++) {
m++;
}
}
}
};
new Thread(r).start();
new Thread(r).start();
Thread.sleep(300);
System.out.println(m);
}
输出:20000
synchronized方法
static int m = 0;
public static void main(String[] args) throws InterruptedException {
//创建一个Runnable类型的对象
Runnable r = new Runnable() {
@Override
public void run() {
synchronized (this){
for (int i = 0; i < 10000; i++) {
add();
}
}
}
};
new Thread(r).start();
new Thread(r).start();
Thread.sleep(300);
System.out.println(m);
}
public static synchronized void add(){
m++;
}
输出:20000
lock锁
static int m = 0;
public static void main(String[] args) throws InterruptedException {
Lock lock = new ReentrantLock();
//创建一个Runnable类型的对象
Runnable r = new Runnable() {
@Override
public void run() {
synchronized (this){
for (int i = 0; i < 10000; i++) {
lock.lock();
m++;
lock.unlock();
}
}
}
};
new Thread(r).start();
new Thread(r).start();
Thread.sleep(300);
System.out.println(m);
}
输出:20000
线程的状态
NEW:新建状态。创建了一个新线程,启动之前处于该状态
RUNNABLE:可运行状态
BLOCKED:阻塞状态
WAITING:无限等待状态
TIMED_WAITING:计时等待状态
TERMINATED:消亡状态
public static void main(String[] args) {
Thread t = new Thread();
//获取线程的状态
Thread.State s = t.getState();
System.out.println(s);//NEW
}
输出:NEW
线程的通信
多个线程在处理同一资源,但是处理动作(线程的任务)却不同
比如:线程A用来生产包子,线程B用来吃包子,包子可以理解为同一资源,线程A与B处理的动作,一个是消费一个是生产,那么A,B之间就存在线程间的通讯
等待唤醒机制
我们需要通过等待唤醒机制使各个线程能有效的利用资源,避免在多个线程处理同一变量时发生争夺。
object类
void wait();//让线程进入等待状态
void wait(long time);//调用该方法,会让线程进入计时等待状态
void notify();//调用该方法,会让线程醒来,接着执行任务
void notifyAll();//调用该方法,会唤醒当前锁对象上等待的所有进程
注意:
1.这些方法都必须写在synchronized代码块或者synchronized方法中
2.调用这些方法的对象,必须和锁对象一致。
3.t.notify方法只能唤醒“t”锁对象上等待的线程
4.调用了wait(不论是否有参数)方法,会自动释放锁对象
我们来用“生产者与消费者”的问题来说明等待唤醒机制
包子铺生产包子,吃货吃包子,当包子没有时(false状态),吃货(消费者线程)等待,包子铺(生产者线程)开始生产包子(包子状态为true)并通知吃货(接触吃货的等待状态),包子铺线程进入等待状态。接下来,吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁,那么就执行吃包子动作,包子吃完(包 子状态为false),并通知包子铺线程(解除包子铺的等待状态),吃货线程进入等待。包子铺线程能否进一步执行则取 决于锁的获取情况。
baozi类
public class baozi{
public boolean flag;//有没有包子,有包子为true没包子为false
}
吃货线程(消费者)
package exc1;
public class chihuo extends Thread{
private baozi bz;
public chihuo(baozi bz) {
super();
this.bz = bz;
}
public void run(){
while (true){
synchronized (bz){
//判断是否有包子
if (bz.flag){
//有包子就吃包子
System.out.println("吃货正在吃包子");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//吃完包子,改变包子的状态
bz.flag = false;
//唤醒等待的线程
bz.notify();
}else {
try {
//没有包子,等待
bz.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
}
包子铺线程(生产者线程)
package exc1;
public class baozipu extends Thread {
private baozi bz;
public baozipu(baozi bz){
super();
this.bz = bz;
}
public void run(){
while (true){
synchronized (bz){
//判断是否有包子
if (bz.flag){
try {
//有包子,不生产,等待
bz.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}else {
//没有包子,生产包子
System.out.println("包子铺没有包子正在生产包子");
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
//改变包子的状态
bz.flag=true;
//唤醒等待的线程
bz.notify();
}
}
}
}
}
测试类
public class test {
public static void main(String[] args) {
baozi bz = new baozi();
new chihuo(bz).start();
new baozipu(bz).start();
}
}
输出:
包子铺没有包子正在生产包子
吃货正在吃包子
包子铺没有包子正在生产包子
吃货正在吃包子
包子铺没有包子正在生产包子
吃货正在吃包子
包子铺没有包子正在生产包子(部分输出).....
线程池
我们使用线程就去创建一个线程,这样实现起来很简单,但是如果需要并发很多线程,那么系统资源就会被频繁的创建线程和销毁线程消耗
这时候就需要线程池:
1.降低资源消耗。减少了创建和销毁线程的次数,每个工作线程都可以被利用,可以执行多个任务。
2.提高响应速度。当任务达到时,任务可以不需要的等到线程就能创建就能立即执行
3.提高线程的可管理性。可以根据系统的承受能力,调整线程池中工作线程的数目
Executors类
static ExecutorService newFiexdThredadPool(int nThread);
ExecutorService接口:
void execute(Runnable r);//执行任务
Future submit(Callable c);
Future<?> submit(Runnable r);
void shutdown();//关闭线程池
Future接口
T get();//必须等子线程把任务执行完成,return以后才可以获取返回的结果。
Callable接口:
T call();
创建线程池的步奏
1.创建线程池对象
2.创建Runnable接口子类对象
3.提交Runnable接口子类对象
4.关闭线程池(一般不做这一步)
例子:
public class test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
};
//创建一个固定线程池对象
ExecutorService es = Executors.newFixedThreadPool(2);
//Future接口:用来记录线程任务执行完毕后产生的结果。线程池创建与使用。
Future<?> future = es.submit(r);
Object result = future.get();//null
System.out.println(result);
//关闭线程池
es.shutdown();
}
}