Java学习笔记Day17:线程(1)

一、并发与并行

并发： 指两个或多个事件在同一个时间段内发生–》交替执行
并行： 指两个或多个事件在同一时刻发生（同时发生）–》同时执行

二、线程与进程

CPU： 中央处理器，对数据进行计算，指挥电脑中软件和硬件干活
内存： 所有的应用程序都需要进入到内存中执行，临时存储RAM

线程： 是指一个内存中运行的应用程序
进程： 线程属于进程，是进程中的一个执行单元，负责程序的执行

多线程的好处：

效率高
多个线程之间互不影响（在不同的栈空间）

三、线程调度

1.分时调度
所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
2.抢占式调度
优先让优先级高的线程使用CPU，如果线程的优先级相同，那么随机选择一个（线程随机性），Java使用的为抢占式调度

四、主线程

主线程： 执行主方法的线程
单线程程序： java程序中只有一个线程
执行从main方法开始，从上到下依次执行

五、创建多线程

第一种方式：创建Thread类的子类

java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类

实现步骤：

创建一个Thread类的子类
在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程做什么）
创建Thread类的子类对象
调用Thread类中的方法start方法，开启新的线程，执行run方法

public class MyThread extends Thread{
    public void run(){
        for(int i=0;i<20;i++){
            System.out.println("run:"+i);
        }
    }
}
public class demo{
    public static void main(String[] args){
        MyThread mt=new MyThread();
        mt.start();
        for(int i=0;i<20;i++){
            System.out.println("main:"+i);
        }
    }
}//程序结果随机打印

Thread常用方法
线程的名称：
主线程：main
新线程：Thread-0 Thread-1 Thread-2

String getName() 返回该线程的名称
long getId()返回此线程的标识符
Thread.State getState()返回此线程的状态
final int getPriority()返回此线程的优先级
final void setPriority()更改此线程的优先级
void join()等待线程停止，内部调用isAlive()
static void yield()让出CPU
final boolean isDaemon()测试一个线程是否是守护线程
非守护线程（主线程）
JVM结束的条件，不是主线程退出就退出，而是所有的非守护线程都退出才会退出
final boolean isAlive()判断线程是否活着,线程不是new和teminal状态
final boolean isinterrupted()
static Thread currentThread() 返回对当前正在执行的线程对象的引用

// 链式编程
System.out.println(Thread.currentThread().getName());

设置线程的名称：

void setName(String name)改变线程名称，使之与参数name相同
创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类（Thread）给子线程起一个名字

public class demo{
    public static void main(String[] args){
        System.out.println(i);
        try{
            Thread.sleep(1000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        }
}

static void sleep(long millis);
是当前正在执行的线程以指定的毫秒暂停（暂时停止执行）毫秒数结束之后，线程继续执行

第二种方式：实现Runnable接口

java.lang.Runnable

实现步骤：
1.创建一个Runnable接口的实现类
2.在实现类中重写Runnable接口的run方法，设置线程任务
3.创建一个Runnable接口的实现类对象
4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5.调用Thread类中的start方法，开启新的线程执行run方法

public class Runnableimpl implements Runnable{
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(Thread);
        }
        }
}


Thread t=new Thread(new Runnableimpl());
t.start();

Thread和Runnable的好处
1.避免了单继承的局限性

一个类只能继承一个类（一个人只能有一个亲爹），类继承了Thread类就不能继承其他类
实现了Runnable接口，还可以继承其他的类，实现其他的接口

2.增强了程序的扩展性，降低了程序的耦合性（解耦）

实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）
实现类中，重写了run方法：用来设置线程任务
创建Thread类对象，调用start方法：用来开启新线程

线程的状态
NEW
RUNNABLE
BLOCKED
TERMIATED
TIMD_WAITING
WAITING

中断线程
方式一：通知不及时

public class StopThread {
    private static class Worker extends Thread{
        private volatile boolean quit=false;
        Worker(){
            super("李四");
        }
        public void setQuit(boolean quit){
            this.quit=quit;
        }
        @Override
        public void run() {
            while(!quit){
                System.out.println(this.getName()+"我正在转账，别烦我");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(this.getName()+"对方是骗子");
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Worker worker=new Worker();
        worker.start();
        System.out.println("我是张三，正在等李四转账");
        Thread.sleep(1000);
        System.out.println("打听到对方是骗子，停止转账");
        worker.setQuit(true);
        System.out.println("通知李四完毕");
        worker.join();
        System.out.println("李四停止转账");
    }
}

方法二：interrupted

class Thread{
    private boolean interrupted=false;
    public void interrupt(){
        this.interrupted=true;
    }
    public boolean isInterrupted(){
        return this.interrupted;
    }
}

调用Thread对象的interrupt()方法，会将对象的interrup status值为true，是建议性的中断
对于Thread对象关联的线程来说，有两种途径获取该信息
1. 如果当前线程正在sleep/wait,以interruptedException的形式通知
2. 否则，需要自行去判断对象中的interrupt status

调用对象的isInterrupted()方法//判断该对象的interrupt status
调用Thread.interrupted()方法//判断的是当前线程对象的
Thread.currentThread().isInterrupted()

public class StopThread {
    private static class Worker extends Thread{
        Worker(){
            super("李四");
        }
        @Override
        public void run() {
            while(!this.isInterrupted()){
                System.out.println(this.getName()+"我正在转账，别烦我");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    System.out.println("我从睡梦中惊醒");
                    break;
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Worker worker=new Worker();
        worker.start();
        System.out.println("我是张三，正在等李四转账");
        Thread.sleep(10*1000);
        System.out.println("打听到对方是骗子，停止转账");
        worker.interrupt();
        System.out.println("通知李四完毕");
        worker.join();
        System.out.println("李四停止转账");
    }
}

1.InterruptedException被抛出，interrupt status被重置（=false）
2.Thread.interrupted()首次返回真实的interrupt status，然后interrupt status=false
3.thread.isInterrupted()不会重置

匿名内部类方式实现线程的创建
（简化代码）

public class demo{
    public static void main(String[] args){
        new Thread(){
            pulic void run(){
                for(int i=0;i<20;i++){
                    System.out.println(Thread.currentThread().getName()+"-->"+"黑马";
                }
            }
        }.start();
        
        Runnable r=new Runnable(){
            public void run(){
                for(int i=0;i<20;i++){
                    System.out.println("hello"+i);
                }
            }
        }
        new Thread(r).start();

ZQQ~BK

发布了118 篇原创文章 · 获赞 12 · 访问量 2585

私信关注