程序、进程、线程

最新推荐文章于 2024-07-02 00:50:11 发布

坚持#

最新推荐文章于 2024-07-02 00:50:11 发布

阅读量248

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_55299825/article/details/119874099

版权

在这里插入图片描述程序：静态代码（没有加载到内存，也没有用CPU去计算）。为完成特定的任务，用某种语言编写的一组指令的集合
进程process：程序的一次执行过程，或是正在运行的一个程序
程序是静态的，进程是动态的
线程Thread：可以根据360安全卫士来理解。可以同时扫描木马，清理垃圾等
一个程序内部的执行路径。main方法就是一个线程。
在这里插入图片描述
方法区和堆属于线程都可以共享的

可以理解收费站模式，一个通道排队过是单核，多个通道同时过时多核

Thread :线程

package com.atguigu.java;

/**
 * 多线程的创建：方式一：继承于Thread类
 * 1.创建一个继承于Thread类的子类
 * 2.重写Thread类的run()方法-->将此线程执行的操作声明在run()中
 * 3.创建Thread类的子类的对象
 * 4.通过此对象调用start()
 * 例子：遍历100以内的所有的偶数
 *
 * @author shkstart
 * @create 2021-08-23 18:27
 */
class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        //通过对象调用start();启动当前线程，调用当前线程的run()
        myThread1.start();
        //问题一：能不能通过直接调用run()的方式启动线程
        //myThread1.run();不可以
        //再启动一个线程，遍历100以内的偶数，不可以还让已经start()的线程去执行，会报错误，需要重写创建一个线程的对象
        MyThread myThread2 = new MyThread();
        myThread2.start();
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                System.out.println(i + "*************");
            }
        }
    }
}

package com.atguigu.exer;

/**
 * 练习：创建两个线程，其中一个线程遍历100以内的偶数，另一个线程遍历100以内的奇数
 *
 * @author shkstart
 * @create 2021-08-23 21:24
 */
public class ThreadDemo {
    public static void main(String[] args) {
        MyThreadOne m1 = new MyThreadOne();
        MyThreadTwo m2 = new MyThreadTwo();
        m1.start();
        m2.start();
    }
}

class MyThreadOne 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 MyThreadTwo extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

匿名类的方式

package com.atguigu.exer;

/**
 * @author shkstart
 * @create 2021-08-23 22:34
 */
public class ThreadDemo2 extends Thread {
    @Override
    public void run() {

        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();


    }
}

class m1 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 m2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}

线程的方法

package com.atguigu.java;

/**
 * 1.测试Thread中的常用方法
 * 2.start()：启动当前线程：调用当前线程的run()方法
 * 3.run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
 * 4.currentThread：静态方法，返回执行当前代码的线程
 * 5.getName():获取当前线程的名字
 * 6. setName()：设置当前线程的名字
 * 7.yield();释放当前CPU的执行权，
 * 8.join();在线程a中调用线程b的join()方法，此时线程a就进入阻塞状态，直到线程b完全执行完后
 * 线程a才结束阻塞状态
 * 9.stop()；已经过时。当执行此方法时，强制结束当前线程
 * 10.sleep(long millitime);让当前线程睡眠指定的millitime毫秒数，在指定的millitime毫秒时间内当前线程是阻塞状态
 * 11.isAlive();判断当前线程是否存活
 * <p>
 * 线程的优先级
 * 1.
 * MAX_PRIORITY：10
 * MIN _PRIORITY：1
 * NORM_PRIORITY：5
 * 2.如何获取和设置当前线程的优先级
 * getPriority();获取线程的优先级
 * setPriority(int p);设置线程的优先级
 * 说明：高优先级的线程要抢占低优先级线程cpu的执行权，但是只是从概率上讲，高优先级的线程高概率的情况下被执行
 * 并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行
 *
 * @author shkstart
 * @create 2021-08-23 23:11
 */
class HelloThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                try {
                    sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" +
                        Thread.currentThread().getPriority() + ":");
            }
            if (i % 20 == 0) {
                yield();//前面省略了this当前类的对象
            }
        }
    }

    public HelloThread(String name) {
        super(name);
    }
}

public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("Thread:1");
        // h1.setName("线程一");
        //S设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);//h1.setPriority(10);
        h1.start();
        //给主线程命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":"
                        + Thread.currentThread().getPriority() + ":");
            }
//            if (i == 20) {
//                try {
//                    h1.join();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
        }
        System.out.println(h1.isAlive());
    }
}

线程的练习

package com.atguigu.java;

/**
 * 例子：创建三个窗口卖票，总票数为100张
 * 存在线程安全问题，待解决
 *
 * @author shkstart
 * @create 2021-08-24 23:00
 */
class Window extends Thread {
    private static int ticket = 100;//此处是重点要加static，不然就是创建3个各为100的对象

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(getName() + ":卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class WindowTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }
}

创建线程的第二种方法，参考API创建
利用Runnable接口

package com.atguigu.java;

/**
 * 创建多线程的方式二，实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run()方法
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.通过Thread类的对象调用start()
 * <p>
 * 比较创建线程的两种方式
 * 开发中：优先选择：实现Runnable接口的方式
 * 原因：1.实现的方式没有类的单继承性的局限性
 * 2.实现的方式更适合处理多个线程有共享数据的情况
 * 联系：public class Thread implements Runnable，Thread类本身就是实现了Runnable接口
 * 相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中
 *
 * @author shkstart
 * @create 2021-08-25 8:48
 */
//1.创建一个实现了Runnable接口的类
class MThread implements Runnable {
    //2.实现类去实现Runnable中的抽象方法：run()方
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

        }
    }
}


public class ThreadTest2 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);//多态
        t1.setName("线程一");
        //5.通过Thread类的对象调用start()1.启动线程，2调用当前线程的run()方法-->调用了Runnable类型的target的run()方法
        t1.start();
        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

练习

package com.atguigu.java;

/**
 * 使用Runnable接口的方式
 * 存在线程安全问题，待解决
 *
 * @author shkstart
 * @create 2021-08-25 9:13
 */
class Window2 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w = new Window2();//这里只是造了一个对象

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }

}

总结：进程可以细化为多个线程
每个线程，拥有自己独立的：栈、程序计数器
多个线程，共享同一个进程中的结构：方法区、堆。
线程通信：wait()/notify()/notifyAll()：此三个方法定义在Object类中

在这里插入图片描述 main方法就是用户线程

坚持#

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
程序、进程、线程

程序：静态代码。进程：程序的一次执行过程，或是正在运行的一个程序程序是静态的，进程是动态的线程：可以根据360安全卫士来理解。可以同时扫描木马，清理垃圾等一个程序内部的执行路径。main方法就是一个线程。方法区和堆属于线程都可以共享的可以理解收费站模式，一个通道排队过是单核，多个通道同时过时多核Thread :线程...
复制链接

扫一扫