1、Process(进程)与Thread(线程)
- 说起进程,就不得不说下程序,程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念
- 而进程是执行程序的一次过程,它是一个动态的概念,是系统资源分配的单位
- 通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是CPU调度和执行的单位
- 在程序运行时,即时没有自己创建线程,后台也会有多个线程,如主线程,gc线程
- main()称之为主线程,为系统的入口,,用于执行整个程序
2、线程的创建
2.1、继承Thread类(重点)
- 自定义线程类继承Thread类
- 重写run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
- 启动线程:子类对象.start()
- 不建议使用:避免 OOP单继承局限性
public class Thread01 extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
//两个线程同时执行
Thread01 thread01 = new Thread01();
thread01.start();
for (int i = 0; i < 200; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
2.2、实现Runnable(重点)
- 定义MyRunnable类实现Runnable接口
- 实现run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
- 启动线程:传入目标对象+Thread对象.start()
- 推荐使用:避免单继承的局限性,灵活方便,方便同一个对象被多个线程使用
public class Runnable_ implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码---"+i);
}
}
public static void main(String[] args) {
Runnable_ runnable_ = new Runnable_();
Thread runnable = new Thread(runnable_);
runnable.start();
// new Thread(runnable_).start();
for (int i = 0; i < 20; i++) {
System.out.println("我在学习多线程---"+i);
}
}
}
- 买票例子:
发现问题:多个线程操作同一个资源的情况下,线程不安全,数据混乱
public class Runnable2_ implements Runnable{
//票数
private int ticketNums=10;
@Override
public void run() {
while(true){
if (ticketNums<=0){
break;
}
//模拟延时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"-->拿到了第"+(ticketNums--)+"票");
}
}
public static void main(String[] args) {
Runnable2_ ticket = new Runnable2_();
new Thread(ticket,"小明").start();
new Thread(ticket,"老师").start();
new Thread(ticket,"黄牛").start();
}
}
2.3、实现Callable接口(了解)
- 实现Callable接口,需要返回值类型
- 重写call方法,需要抛出异常
- 创建目标对象
- 创建执行服务:ExecutorService ser =Executors.newFixedThreadPool(1);
- 提交执行:Futrue< Boolean > result1=ser.submit(t1);
- 获取结果:boolean r1=result.get()
- 关闭服务:ser.shutdownNow();
public class Callable_ implements Callable {
@Override
public Object call() throws Exception {
for (int i = 0; i < 20; i++) {
System.out.println("我在看代码---"+i);
}
return true;
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
Callable_ t1 = new Callable_();
ExecutorService ser = Executors.newFixedThreadPool(1);
Future<Object> result = ser.submit(t1);
Object rs1 = result.get();
System.out.println(rs1);
ser.shutdown();
}
}
3、Lamda表达式
- 为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来很简洁
- 去掉一推没有意义的代码,只留下核心的逻辑
- 函数式接口的定义:
- 任何接口,如果只包含唯一一个抽象方法,那么它就是一个函数式接口
public interface Runnable{
public abstract void run();
}- 对于函数式接口,我们可以通过lambda表达式来创建该接口的对象
public class Lambda_ {
public static void main(String[] args) {
//匿名内部类
ILike iLike = new ILike() {
@Override
public void lambda(int a) {
System.out.println("1 like lambda1"+a);
}
};
iLike.lambda(520);
//lambda简化
iLike=(a)->{System.out.println("1 like lambda2"+a);
};
iLike.lambda(520);
//简化
iLike=(a)-> System.out.println("1 like lambda3"+a);
iLike.lambda(520);
}
}
//函数是接口
interface ILike{
void lambda(int a);
}
4、线程状态
4.1、线程方法
- setPriority(int newPriority):更改线程的优先级
- static void sleep(long millis):在指定的毫秒数内让当前正在执行的线程休眠
- viod join():等待该线程终止
- static void yield():暂停当前正在执行的线程对象,并执行其他线程
- void interrupt():中断线程,别用这个方法
- boolean idAlive():测试线程是否处于活动状态
- setPriority():设置线程优先级
5、守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 用户线程执行完毕,即守护线程也停止
- 如:后台记录操作日志,监控内存,垃圾回收等待
public class Runnable_3 {
public static void main(String[] args) {
God god = new God();
You you = new You();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认为false表示为用户线程,正常的线程都是用户线程
thread.start();//守护线程启动
new Thread(you).start();
}
}
class God implements Runnable{
@Override
public void run() {
while(true){
System.out.println("上帝保佑着你");
}
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("你一直活着");
}
System.out.println("good by");
}
}
6、线程同步
- 由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排斥所,独占资源,其他线程必须等待,使用后释放锁即可,存在一下问题:
- 一个线程持有锁会导致其他所有需要次锁的线程挂起;
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题;
- 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题
public class 线程同步 {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"a").start();
new Thread(buyTicket,"b").start();
new Thread(buyTicket,"c").start();
}
}
class BuyTicket implements Runnable{
private int ticketNum=10;
boolean flag=true;
@Override
public void run() {
while(flag){
buy();
}
}
private synchronized void buy(){
if (ticketNum<0){
flag=false;
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"还剩"+ticketNum--);
}
}
7、死锁
- 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都会停止执行的情况,某一个同步块同时拥有两个以上对象的锁时,就可能会发生死锁的问题
8、Lock锁
public class Lock_ {
public static void main(String[] args) {
Lock lock = new Lock();
new Thread(lock).start();
new Thread(lock).start();
new Thread(lock).start();
}
}
class Lock implements Runnable{
int ticket=10;
//定义lock锁(可重用锁)
private final ReentrantLock lock= new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock();//加锁
if (ticket>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticket--);
}else{
break;
}
}finally {
//解锁
lock.unlock();
}
}
}
}
9、synchronized与Lock的对比
- Lock是显示锁(手动开启和关闭锁,别忘记关闭所)synchronized是隐式锁,出了作用域自动释放
- Lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好,并且具有更好的扩展性
- 优先使用顺序:
- Lock>同步代码块>同步方法