Java多线程基础炒鸡详细(一)

最新推荐文章于 2024-07-22 14:15:06 发布

Zdde_

最新推荐文章于 2024-07-22 14:15:06 发布

阅读量119

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_43213137/article/details/107800958

版权

Java 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

基础概念

1.程序：程序是为了完成特定任务、用某种语言编写的一组指令的集合。一段静态的代码，静态对象。
2.进程：是程序的一次执行的过程，或是正在运行的一个程序。是一个动态的过程：进程的产生、存在和消亡的过程。——生命周期。
3.线程，进程可以进一步细化为线程，是一个程序内部的一条执行路径。
①若一个进程同一时间并行执行多个线程，那就是支持多线程的
②每个线程拥有独立的运行栈和程序计数器，线程切换的开销小
③一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
④一个java应用程序至少有三个线程，主线程，垃圾回收线程，异常处理线程

使用场景

多线程的优点：
1.提高应用程序的响应
2.提高计算机系统CPU使用率
3.改善程序结构

线程的创建方式

1.JDK1.5之前创建新线程有两种方式
①继承Thread类的方式
②实现Runnable接口的方式

创建实现

1.方式一

/**
 * 方式一 继承Thread类 重写Thread里面的run方法
 */
class ThreadTest extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
            //System.out.println(getName()+":"+i);两种写法效果一致
            //获取当前线程名并且输出 i
        }
    }
}
public class MyTest {
    public static void main(String[] args) {
        ThreadTest test1 = new ThreadTest();
        ThreadTest test2 = new ThreadTest();
        //创建两个新线程 必须调用start()方法才能开启新线程
        test1.start();
//        test1.start();同一个实例对象不能调用两次start()方法 会抛出异常IllegalThreadStateException
//        test1.run(); 不能直接调用run方法，只是普通的调用类的成员方法不会开启多线程
        test2.start();

    }
}

那么学习一个类最主要的先要看看它的构造器有哪些：在这里插入图片描述
ok，可以看到它有这么多构造器，先看这几个：

Thread(Runnable) //这个构造器就是方式二创建新线程了，接收一个Runnable接口，该接口里面
                //只有一个run()方法
Thread(Runnable,String) //创建新线程并且给线程命名
Thread(String) //创建线程并且命名

①方式一方法练习：

/**
 * Thread 类中的常用方法
 * 1.start():启动当前线程，调用当前线程的run方法
 * 2.run()：通常需要重写Thread类中的run()方法，当前方法需要执行的操作写此方法中
 * 3.currentThread():静态方法，返回执行当前代码的线程
 * 4.getName():获取当前线程的名字
 * 5.setName():设置当前线程的名字
 * 6.yield():释放当前cpu的执行权
 * 7.join():在线程A中调用线程B的join()方法，此时线程A处于阻塞状态，知道线程B结束，线程A才结束阻塞
 * 8.stop():强制当前线程死亡，不建议使用 已过时
 * 9.sleep(long time):让当前的线程“睡眠”指定毫秒，指定的时间内当前线程是阻塞状态
 * 10.isAlive() 判断当前线程是否存活，返回Boolean类型
 */
 public class MethodTest {
    public static void main(String[] args) throws InterruptedException {
        Method1 method1 = new Method1("dd");
        method1.start();
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if (i==20){
                method1.join();
            }
        }
    }
}


class Method1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
//                try {
//                    sleep(200);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                System.out.println(getName()+":"+i);
            }
//            if (i % 4==0){
//                yield();
//            }
        }
    }
    public      Method1(String name){
        super(name);
    }
}

②线程的优先级

/**
 * 线程的优先级
 * 1.
 * MAX_PRIORITY:10
 * MIN_PRIORITY:1
 * NORM_PRIORITY:5 ——>默认的优先级
 * 2.如何获取和设置优先级
 * getPriority():获取线程的优先级
 * setPriority():设置线程的优先级
 *说明：高优先级的线程要抢占低优先级线程CPU的执行权。但是只是从概率上讲，优先级高代表的是概率高
 * 不是说低优先级一定比低优先级后执行
 */
 
public class MethodTest {
    public static void main(String[] args) throws InterruptedException {
        Method1 method1 = new Method1("dd");
//        method1.setPriority(Thread.MAX_PRIORITY);
        method1.start();
//        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            if (i==20){
                method1.join();
            }
        }
    }
}


class Method1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(getName()+":"+i);
            }
        }
    }
    public      Method1(String name){
        super(name);
    }
}

③现有100张票需要三个售票点买票，如何设计多线程的方式实现买票呢？（不考虑线程安全问题）

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

class WindowTest extends Thread{
    private static int ticket =  100; //方式一：使用static 控制同一份买票数量
    @Override
    public void run() {
        while (true){
            if (ticket>0){
                System.out.println(getName()+"：买票，号码:"+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}

2.方式二：

/**
 * 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中
 * 5.调用Thread类中的start()方法
 */

class MThread implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

public class Thread2Test {
    public static void main(String[] args) {
        MThread m = new MThread();
        Thread thread = new Thread(m);
        thread.start();//此时start() 开启线程后 会调用当前线程的run()方法 此时不是调用MThread()里面重写的run()方法
    }
}

①利用方式二实现买票问题

/**
 * 不使用static的方式多线程处理同一数据源
 */
class Window2Test 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 Window2 {
    public static void main(String[] args) {
        Window2Test window2Test = new Window2Test();
        Thread thread1 = new Thread(window2Test);
        Thread thread2 = new Thread(window2Test);
        Thread thread3 = new Thread(window2Test);
        thread1.setName("1");
        thread2.setName("2");
        thread3.setName("3");
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

那么第二种方式创建新线程呢，其实也使用到了多态的特性，Thread构造器接受一个Runnable类型的参数，也就是接收我们Runnable接口的实现类，并且实现了里面的run()方法，如果有多个类实现了该接口，那么最终run()方法就会执行不同的逻辑，也就是有不同的表现新式。同一个接口，使用不同的实例执行不同的操作。

问题

1.继承方式和实现方式有什么区别和联系呢？
答：联系：继承的Thread类实现了 Runnable接口
区别：继承Thread类：线程代码放在Thread子类中，实现Runnable：线程代码存在在接口子类中
2.实际开发中，是使用继承Thread还是使用实现Runnable接口呢？为什么？
答：
实际开发中，主要使用Runnable接口，
原因：

1，实现的方式避免了单继承的局限
2，多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。

Zdde_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java多线程基础炒鸡详细(一)

基础概念1.程序：程序是为了完成特定任务、用某种语言编写的一组指令的集合。一段静态的代码，静态对象。2.进程：是程序的一次执行的过程，或是正在运行的一个程序。是一个动态的过程：进程的产生、存在和消亡的过程。——生命周期。3.线程，进程可以进一步细化为线程，是一个程序内部的一条执行路径。①若一个进程同一时间并行执行多个线程，那就是支持多线程的②每个线程拥有独立的运行栈和程序计数器，线程切换的开销小③一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象，可以访问相同的变量和对
复制链接

扫一扫

专栏目录