Java进程与线程

最新推荐文章于 2023-10-10 12:40:22 发布
最新推荐文章于 2023-10-10 12:40:22 发布
阅读量206 收藏
点赞数 2
分类专栏： 多线程 文章标签： java 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44515800/article/details/121615426
版权

1.实现多线程

1.1进程

进程：是正在进行中的程序

  • 是系统进行资源分配和调用的独立单位
  • 每一个进程都有它自己的内存空间和系统资源

1.2线程

线程：是进程中的单个顺序控制流，是一条执行路径

  • 单线程：一个进程如果有一条执行路径，称为单线程程序

  • 多线程：一个进程如果有多条执行路径，称为多线程程序

1.3方式一 ：继承 Thread父类

public class MyThread extends Thread {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(i);
        }
    }
    //为什么重写run()方法？
    //因为run()是用来封装被线程执行的代码
}

/*
    方式1：继承Thread类
        1:定义一个类MyThread继承Thread类
        2:在MyThread类中重写run()方法
        3:创建MyThread类的对象
        4:启动线程
 */
public class MyThreadDemo {
    public static void main(String[] args) {
        MyThread my1 = new MyThread();
        MyThread my2 = new MyThread();

//        my1.run();
//        my2.run();
        //void start​() 导致此线程开始执行; Java虚拟机调用此线程的run方法
        my1.start();
        my2.start();
        //run()方法和start()方法的区别:
        //run()：封装线程执行的代码，直接调用，相当于普通方法的调用
        //start()：启动线程；然后由JVM调用此线程的run()方法
    }
}

1.4设置和获取线程名称

Thread类中获取和设置线程名称的方法
    void setName(String name)：将此线程的名称更改为等于参数 name
    String getName()：返回此线程的名称

public class MyThread extends Thread {

    public MyThread() {}

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

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

public class MyThreadDemo {
    public static void main(String[] args) {
//        MyThread my1 = new MyThread();
//        MyThread my2 = new MyThread();
//
//        //void setName(String name)：将此线程的名称更改为等于参数 name
//        my1.setName("高铁");
//        my2.setName("飞机");

        //Thread(String name)
//        MyThread my1 = new MyThread("高铁");
//        MyThread my2 = new MyThread("飞机");
//
//        my1.start();
//        my2.start();

        //static Thread currentThread​() 返回对当前正在执行的线程对象的引用
        System.out.println(Thread.currentThread().getName());
    }
}

1.5线程调度

线程有两种调度模型

  • 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
  • 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些

JAVA使用抢占式调度模型

hread类中设置和获取线程优先级的方法：

  • public final void setPriority(int newPriority)：更改此线程的优先级
  • public final int getPriority()：返回此线程的优先级
public class ThreadPriority extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

public class ThreadPriorityDemo {
    public static void main(String[] args) {
        ThreadPriority tp1 = new ThreadPriority();
        ThreadPriority tp2 = new ThreadPriority();
        ThreadPriority tp3 = new ThreadPriority();

        tp1.setName("高铁");
        tp2.setName("飞机");
        tp3.setName("汽车");

        //public final int getPriority()：返回此线程的优先级
//        System.out.println(tp1.getPriority()); //5
//        System.out.println(tp2.getPriority()); //5
//        System.out.println(tp3.getPriority()); //5

        //public final void setPriority(int newPriority)：更改此线程的优先级
//        tp1.setPriority(10000); //IllegalArgumentException
//        System.out.println(Thread.MAX_PRIORITY); //10
//        System.out.println(Thread.MIN_PRIORITY); //1
//        System.out.println(Thread.NORM_PRIORITY); //5

        //设置正确的优先级
        tp1.setPriority(5);
        tp2.setPriority(10);
        tp3.setPriority(1);


        tp1.start();
        tp2.start();
        tp3.start();
    }
}

1.6线程控制

  1. static void sleep(long millis)：使当前正在执行的线程停留（暂停执行）指定的毫秒数
public class ThreadSleep extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
            //线程执行一次休息一秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
        }
    }
}

public class ThreadSleepDemo {
    public static void main(String[] args) {
        ThreadSleep ts1 = new ThreadSleep();
        ThreadSleep ts2 = new ThreadSleep();
        ThreadSleep ts3 = new ThreadSleep();

        ts1.setName("曹操");
        ts2.setName("刘备");
        ts3.setName("孙权");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}
  1. void join()：等待这个线程死亡
public class ThreadJoin extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1 = new ThreadJoin();
        ThreadJoin tj2 = new ThreadJoin();
        ThreadJoin tj3 = new ThreadJoin();

        tj1.setName("康熙");
        tj2.setName("四阿哥");
        tj3.setName("八阿哥");
		
        tj1.start();
        //tj1线程执行完执行其它
        try {
            tj1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        tj2.start();
        tj3.start();
    }
}
  1. void setDaemon​(booleanon)：将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
public class ThreadDaemon extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ":" + i);
        }
    }
}

public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1 = new ThreadDaemon();
        ThreadDaemon td2 = new ThreadDaemon();

        td1.setName("关羽");
        td2.setName("张飞");

        //设置主线程为刘备
        Thread.currentThread().setName("刘备");

        //设置守护线程
        //主线程结束后守护线程逐渐结束
        td1.setDaemon(true);
        td2.setDaemon(true);

        td1.start();
        td2.start();

        for(int i=0; i<10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

1.7线程生命周期

在这里插入图片描述

1.8方式2：实现Runnable接口

    1:定义一个类MyRunnable实现Runnable接口
    2:在MyRunnable类中重写run()方法
    3:创建MyRunnable类的对象
    4:创建Thread类的对象，把MyRunnable对象作为构造方法的参数
    5:启动线程

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for(int i=0; i<100; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class MyRunnableDemo {
    public static void main(String[] args) {
        //创建MyRunnable类的对象
        MyRunnable my = new MyRunnable();

        //创建Thread类的对象，把MyRunnable对象作为构造方法的参数
        //Thread​(Runnable target)
//        Thread t1 = new Thread(my);
//        Thread t2 = new Thread(my);
        //Thread​(Runnable target, String name)
        Thread t1 = new Thread(my,"高铁");
        Thread t2 = new Thread(my,"飞机");

        //启动线程
        t1.start();
        t2.start();
    }
}

相比继承Thread类，实现Runnable接口的好处：

  • 避免了Java单继承的局限性
  • 适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

2.线程同步

2.1同步代码块

格式

//这段代码只有一个线程执行
synchronized(任意对象){
		//多条语句操作共享数据的代码
		//相当于给代码加了锁，任意对象就可以看成是一把锁
}
//好处：解决了多线程的数据安全问题
//弊端：线程很多时，每个线程都会去判断同步上的锁，很耗费资源，降低运行效率

public class SellTicket implements Runnable {
    private int tickets = 100;
    private Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            //tickets = 100;
            //t1,t2,t3
            //假设t1抢到了CPU的执行权
            //假设t2抢到了CPU的执行权
            synchronized (obj) {
                //t1进来后，就会把这段代码给锁起来
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                        //t1休息100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //窗口1正在出售第100张票
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--; //tickets = 99;
                }
            }
            //t1出来了，这段代码的锁就被释放了
        }
    }

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

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

2.2同步方法

同步方法：就是把synchronized关键字加到方法上
格式：修饰符 synchronized 返回值类型 方法名(方法参数){ }
同步方法的锁对象是：this

同步静态方法：就是把synchronized关键字加到静态方法上
格式：修饰符 static synchronized 返回值类型 方法名(方法参数){ }
同步方法的锁对象是：类名.class

public class SellTicket implements Runnable {
//    private int tickets = 100;
    private static int tickets = 100;
    private Object obj = new Object();
    private int x = 0;

    @Override
    public void run() {
        while (true) {
            if (x % 2 == 0) {
//                synchronized (obj) {
//                synchronized (this) {
                synchronized (SellTicket.class) {
                    if (tickets > 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                        tickets--;
                    }
                }
            } else {
                sellTicket();
            }
            x++;
        }
    }

//    private synchronized void sellTicket() {
//        if (tickets > 0) {
//            try {
//                Thread.sleep(100);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
//            tickets--;
//        }
//    }

    private static synchronized void sellTicket() {
        if (tickets > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
            tickets--;
        }
    }

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

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

2.3线程安全的类

/*
    线程安全的类：
        StringBuffer
        Vector
        Hashtable
 */
public class ThreadDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        StringBuilder sb2 = new StringBuilder();

        Vector<String> v = new Vector<String>();
        ArrayList<String> array = new ArrayList<String>();

        Hashtable<String,String> ht = new Hashtable<String, String>();
        HashMap<String,String> hm = new HashMap<String, String>();

        //static <T> List<T> synchronizedList​(List<T> list) 返回由指定列表支持的同步（线程安全）列表
        List<String> list = Collections.synchronizedList(new ArrayList<String>());
    }
}

2.4Lock锁

Lock中提供了获得锁和释放锁的方法

  • void lock()：获得锁
  • void unlock()：释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

private Lock lock = new ReentrantLock();

  • ReentrantLock​()：创建一个ReentrantLock的实例
public class SellTicket implements Runnable {
    private int tickets = 100;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

public class SellTicketDemo {
    public static void main(String[] args) {
        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");

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

生产者消费者模式描述

为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法，这几个方法在Object类中Object类的等待和唤醒方法：
| 方法名 |说明 ||void wait|--|| | |


public class Box {
    //定义一个成员变量，表示第x瓶奶
    private int milk;
    //定义一个成员变量，表示奶箱的状态
    private boolean state = false;

    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk) {
        //如果有牛奶，等待消费
        if(state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果没有牛奶，就生产牛奶
        this.milk = milk;
        System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");

        //生产完毕之后，修改奶箱状态
        state = true;

        //唤醒其他等待的线程
        notifyAll();
    }

    public synchronized void get() {
        //如果没有牛奶，等待生产
        if(!state) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第" + this.milk + "瓶奶");

        //消费完毕之后，修改奶箱状态
        state = false;

        //唤醒其他等待的线程
        notifyAll();
    }
}

/*
    生产者消费者案例中包含的类：
        1:奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
        2:生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
        3:消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作
        4:测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下
            A:创建奶箱对象，这是共享数据区域
            B:创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
            C:创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
            D:创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
            E:启动线程
 */
public class BoxDemo {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
        Box b = new Box();

        //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
        //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        Customer c = new Customer(b);

        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

        //启动线程
        t1.start();
        t2.start();
    }
}


public class Customer implements Runnable {
    private Box b;

    public Customer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}

public class Producer implements Runnable {
    private Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        for(int i=1; i<=30; i++) {
            b.put(i);
        }
    }
}
反派的大佬
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
java线程进程锁资源
02-12
java线程进程锁资源111111
JAVA进程和线程
最新发布
程序猿追的博客
11-06 8277
进程就是正在运行的程序，它是系统资源调度的独立单位，并且一个进程可以执行多个任务，而线程就是程序执行的任务，它是程序使用CPU的基本单位，因此也可以说线程是依赖于进程的。像比如任务管理器里面的运行任务就是线程。
Java 线程、进程
单枪匹码
08-25 1147
1、什么是进程：process 进程时操作系统中运行的一个任务（一个应用程序运行在一个进程中）。 进程时一块包含了某些资源的内存区域，操作系统利用进程把它的工作划分为一些功能单元。 进程中包含的一个或多个执行单元称为线程，进程还拥有一个私有的虚拟地址空间，该空间仅能被它所包含的线程访问。 线程只能归属于一个进程，并且它只能访问该进程所拥有的资源，当操作系统创建一个进程后，该进程会自动申请一个名为主线程或者首要线程的线程。 2、什么是线程：thread 一个线程是进程的一个顺序执行流。 同类的多个线程共享一块
JAVA多线程详解（超详细）
m0_74823434的博客
10-10 9640
程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。
【Java多线程学习1】什么是进程、线程，什么是并发、并行及线程的创建和线程的基本使用
weixin_43950588的博客
01-02 711
什么是线程、进程，什么是并发、并行及线程的创建和基本使用
Java多线程基础-3：进程与线程间的区别的联系
wyd_333的博客
03-25 723
分条概括说明进程和线程之间的区别和联系。
bank.rar_进程与线程_Java_
08-12
银行账户的存取款线程设计，模拟银行的存取款线程
mgbqhol.zip_进程与线程_Java_
08-10
org
Java_Thread.rar_进程与线程_Java_
08-11
线程是一个程序的多个执行路径，执行调度的单位，依托于进程存在
downloadDemo.rar_进程与线程_Java_
08-11
这是一个多线程下载的实例，能够实现线程并发下的下载操作
JAVA线程与进程的区别
08-07
JAVA线程与进程的区别JAVA线程与进程的区别
Java-进程和线程
wrb88881203的博客
04-14 137
了解线程和进程
JAVA 进程线程详解
weixin_68320784的博客
04-09 1955
线程和进程 一、进程 进程是指运行中的程序，比如我们使用QQ，就启动该进程分配内存空间. 进程是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自升的产生，存在和消亡的过程 二、线程 线程是由进程创建的，是进程的一个实体 一个进程可以拥有多个线程 一个想线程还可以创建它的子线程 三、其他概念 单线程：同时允许执行一个线程 多线程：同一个时刻，可以执行多个线程 比如：QQ可以打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件 并发：同一个时刻，
深入理解Java进程与线程
pleasenoerror的博客
07-09 428
深入理解Java进程与线程
进程和线程的区别
3NG
03-07 858
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于： 简而言之,一个程序至少有一个进程,一个进程至少有一个线程. 线程的划分尺度小于进程，使得多线程程序的并发性高。 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺
java的线程与进程
m0_74746843的博客
12-07 206
java的线程有进程
Java-进程与线程
qq_51302219的博客
08-04 476
java进程、线程基础
java的进程和线程_java进程和线程区别与不同
06-03
Java进程和线程的概念与普通的进程和线程概念基本相同，但是在Java语言中，Java进程和线程的实现方式与操作系统有所不同。 Java进程是指在操作系统中创建的Java虚拟机实例，每个Java进程都有自己的独立内存空间和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

反派的大佬

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值