多线程概述
1.线程与进程
进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。
线程：
（1）是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程最少有一个线程。
（2）线程实际是在进程基础上的进一步规划，一个进程启动之后，里面的若干执行路径又可以划分为若干个线程。
2.线程调度
（1）分时调度
所有线程轮流使用cpu的使用权，平均分配每个线程占用cpu的时间。
（2）优先式调度
优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个（线程随机性），Java使用的是抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核心而言，某个时刻，只能执行一个线程，而CPU在多个线程之间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程并不能提高程序的运行速度，但是能够提高程序运行效率，让CPU的使用率更高。
3.同步与异步
同步：排队执行，效率低但是安全
异步：同时执行，效率高但是数据不安全
4.并发与并行
并发：指两个或多个事件在同一时间段内发生。
并行：指两个或多个事件在同一时刻发生（同时发生）
实现多线程
1.继承Thread
每个线程都有自己的栈空间，公用一个堆内存。
public class Demo02 extends Thread{
/**
* 线程要执行的任务
*/
@Override
public void run() {
for(int i = 0 ; i < 10;i++){
System.out.println("分支线程"+i);
}
}
public class Demo01 {
public static void main(String[] args) {
Demo02 demo02 = new Demo02();
demo02.start();
for(int i = 0 ; i <10;i++){
System.out.println("主线程"+i);
}
}
}
2.实现Runnable
public class Demo02 implements Runnable{
/**
* 线程要执行的任务
*/
@Override
public void run() {
for(int i = 0 ; i < 10;i++){
System.out.println("分支线程"+i);
}
}
}
实现Runnable与继承Thread相比有如下优势：
（1）通过创建任务，让后分配给线程的方式实现的多线程，更适合多个线程同时执行相同任务的情况。
（2）可以避免单继承所带来的局限性
（3）任务与线程本身是分离的，提高了程序的健壮性
（4）线程池奇数，接收Runnable类型的任务，不接收Thread类型的线程。
3.Callable
使用步骤：
（1）编写类实现callable接口，实现call方法。
（2）创建FutureTask对象，并传入第一步编写的callable类对象
（3）通过Thread启动线程
Runnable与Callable的不同点：
Runnable没有返回值，Callable可以返回执行结果。
Callable接口的call方法允许抛出异常，Runnable的run方法不能抛出异常。
4.线程的中断
一个线程是一个独立的执行路径，它是否应该结束，应该由其自身决定。
@Override
public void run() {
for(int i = 0 ; i < 10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("线程已中断");
return;
}
}
}
public static void main(String[] args) {
Demo02 demo02 = new Demo02();
Thread thread = new Thread(demo02);
thread.start();
for(int i = 0 ; i <5;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//给线程添加中断标记
thread.interrupt();
}
5.守护线程
线程分为守护线程和用户线程
用户线程：当一个进程不包含任何的存活的用户线程时，结束；
守护线程：守护用户线程，当最后一个用户线程结束时，所有守护线程自动死亡。
thread.setDaemon(true);
线程安全问题
当三个线程同时执行卖票操作的时候：
public class Demo03 {
public static void main(String[] args) {
MyThread thread = new MyThread();
new Thread(thread).start();
new Thread(thread).start();
new Thread(thread).start();
}
}
class MyThread implements Runnable{
int count = 10;
@Override
public void run() {
while(count > 0){
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println("卖票成功，余票为："+count);
}
}
}
控制台：
卖票成功，余票为：1
正在准备卖票
卖票成功，余票为：0
卖票成功，余票为：-1
卖票成功，余票为：-2
Process finished with exit code 0
1.同步代码块
要看同一把锁
class MyThread implements Runnable{
int count = 10;
Object o = new Object();
@Override
public void run() {
while(true){
synchronized(o){
if(count > 0){
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"卖票成功，余票为："+count);
}else{
break;
}
}
}
}
}
2.同步方法
public synchronized boolean sale(){
if(count > 0){
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"卖票成功，余票为："+count);
return true;
}
return false;
}
同步方法的锁对象是this，如果是静态修饰的话是当前类.class。
3.显示锁Lock
private Lock l = new ReentrantLock();
@Override
public void run() {
while(true){
l.lock();
if(count > 0){
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"卖票成功，余票为："+count);
}else{
break;
}
l.unlock();
}
}
线程通信
package com.zhifei.list;
public class Demo4 {
public static void main(String[] args) {
Food food = new Food();
Cook cook = new Cook(food);
new Thread(cook).start();
Waiter waiter = new Waiter(food);
new Thread(waiter).start();
}
static class Cook implements Runnable{
private Food food;
public Cook(Food food) {
this.food = food;
}
@Override
public void run() {
for(int i = 0 ; i < 100;i++){
if(i%2 == 0){
food.setNameAndTaste("老干妈炒鸡蛋","麻辣味");
}else{
food.setNameAndTaste("青椒炒肉盖饭","香辣味");
}
}
}
}
static class Waiter implements Runnable{
private Food food;
public Waiter(Food food) {
this.food = food;
}
@Override
public void run() {
for(int i = 0 ; i < 100;i++){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
food.get();
}
}
}
static class Food{
private String name;
private String taste;
private boolean flag = true;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTaste() {
return taste;
}
public void setTaste(String taste) {
this.taste = taste;
}
public synchronized void setNameAndTaste(String name,String taste){
if(flag){
this.name = name;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.taste = taste;
flag = false;
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void get(){
if(!flag){
System.out.println("服务员端走的菜是："+this.name+",味道是："+this.taste);
flag = true;
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
线程池
1.缓存线程池
长度无限制。执行流程如下：
（1）判断线程池是否存在空闲线程
（2）存在则使用
（3）不存在，则创建线程，并放入线程池，然后使用。
public class ThreadPool {
public static void main(String[] args) {
ExecutorService service = Executors.newCachedThreadPool();
//向线程池中添加任务
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"缓存线程池任务------1");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"缓存线程池任务------2");
}
});
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"缓存线程池任务------3");
}
});
}
}
2.定长线程池
长度是指定的数值。
执行流程：
（1）判断线程池是否存在空闲线程
（2）存在则使用
（3）不存在空闲线程，且线程池未满的情况下，则创建线程，并放入线程池，让后使用
（4）不存在空闲线程，且线程池已满的情况下，则等待线程池存在空闲线程。
public class ThreadPool {
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(2);
//向线程池中添加任务
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"定长线程池任务------1");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"定长线程池任务------2");
}
});
service.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"定长线程池任务------3");
}
});
}
}
3.单线程线程池
执行流程：
（1）判断线程池的那个线程是否空闲
（2）空闲则使用
（3）不空闲，则等待，池中的单个线程空闲后，使用
ExecutorService service = Executors.newSingleThreadExecutor();
4.周期性任务定长线程池
执行流程：
（1）判断线程池是否存在空闲线程
（2）存在则使用
（3）不存在空闲线程，且线程池未满的情况下，则创建线程，放入线程池，然后使用
（4）不存在空闲线程，且线程池已满的情况下，则等待线程池中存在空闲线程。
周期任务执行时：
定时执行，当某个实际触发时，自动执行某任务。
public class ThreadPool {
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
//定时执行一次 参数：定时执行的任务 时长 时长单位
/*service.schedule(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+": 定长线程池");
}
},5, TimeUnit.SECONDS);*/
/**
* 周期执行任务
* 参数1：任务
* 参数2：延迟时长数字（第一次执行在什么时间以后）
* 参数3：周期时长数字（每隔多久执行一次）
* 参数4：时长数字的单位
*/
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("周期定长线程池");
}
},5,1,TimeUnit.SECONDS);
}
}
扫一扫
6044
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
