1 Day16--多线程1

最新推荐文章于 2023-09-30 14:47:29 发布

abu1216

最新推荐文章于 2023-09-30 14:47:29 发布

阅读量82

点赞数

本文链接：https://blog.csdn.net/abu1216/article/details/110359047

版权

1.1 进程

1.1.2 特点

l 独立性：进程是系统中独立存在的实体，它可以拥有自己的独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。

l 动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念，进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具备的。

l 并发性：多个进程可以在单个处理器上并发执行，多个进程之间不会互相影响。

1.2 线程

1.2.1 概念

线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程可以开启多个线程。

多线程扩展了多进程的概念，使得同一个进程可以同时并发处理多个任务。

简而言之，一个程序运行后至少一个进程，一个进程里包含多个线程。

如果一个进程只有一个线程，这种程序被称为单线程。

如果一个进程中有多条执行路径被称为多线程程序。

1.2.2 进程和线程的关系

从上图中可以看出一个操作系统中可以有多个进程，一个进程中可以有多个线程，每个进程有自己独立的内存，每个线程共享一个进程中的内存，每个线程又有自己独立的内存。（记清这个关系，非常重要！）

所以想使用线程技术，得先有进程，进程的创建是OS创建的，你能实现吗？不能，一般都是c或者c++语言完成的。

1.3 多线程的特性

1.3.2 线程状态

线程生命周期，总共有五种状态：

1) 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread()；

2) 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。处于就绪状态的线程，只是说明此线程已经做好了准备，随时等待CPU调度执行，并不是说执行了t.start()此线程立即就会执行；

3) 运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此时线程才得以真正执行，即进入到运行状态。注：就绪状态是进入到运行状态的唯一入口，也就是说，线程要想进入运行状态执行，首先必须处于就绪状态中；

4) 阻塞状态（Blocked）：处于运行状态中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到其进入到就绪状态，才有机会再次被CPU调用以进入到运行状态；

5) 根据阻塞产生的原因不同，阻塞状态又可以分为三种：

a) 等待阻塞：运行状态中的线程执行wait()方法，使本线程进入到等待阻塞状态；

b) 同步阻塞：线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态；

c) 其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

6) 死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。Start()方法是一个native方法，它将通知底层操作系统，最终由操作系统启动一个新线程，操作系统将执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。

模拟开启多个线程，每个线程调用run()方法

1.4.2 常用方法

String getName()

返回该线程的名称。

static Thread currentThread()

返回对当前正在执行的线程对象的引用。

void setName(String name)

改变线程名称，使之与参数 name 相同。

static void sleep(long millis)

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。

void start()

使该线程开始执行；Java 虚拟机调用该线程的 run 方法。

Thread(String name)

分配新的 Thread 对象。

1.4.3 测试

package seday13new;

public class Test1 {

public static void main(String[] args) {

//3、创建线程对象

ThreadDemo t1 = new ThreadDemo("钢铁侠");

ThreadDemo t2 = new ThreadDemo("美队");

//4、开启线程：谁抢到资源谁就先执行

t1.start();

t2.start();

//t1.run();//当做常规方法调用，且不会发生多线程现象

}

//1、作为Thread的子类，并重写run方法。把多线程的业务写在run方法中

class ThreadDemo extends Thread{

public ThreadDemo() {}

public ThreadDemo(String name) {

super(name);

}

@Override

public void run() {

//2、默认实现是super.run();

for (int i = 0; i < 10; i++) {

System.out.println(getName()+i);

}

执行结果：

hello0

hello1

hello2

hello3

hello4

hello5

hello6

hello7

hello8

hello1

hello2

hello3

hello9

hello4

hello5

hello6

hello7

hello8

hello9

注意：从上面结果可以确认，start()方法只是通知操作系统线程就绪，具体什么时间执行，操作系统来决定，我们JVM已经控制不了了。

1.5 多线程创建2：实现Runnable接口

1.5.1 概述

如果自己的类已经extends另一个类，就无法多继承，此时，可以实现一个Runnable接口。

1.5.2 常用方法

void run()

使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。

1.5.3 测试

package seday13new;

public class Test2 {

public static void main(String[] args) {

MyThread t = new MyThread ();

//2，构造创建对象，传入Runnable子类

Thread target = new Thread(t);

Thread target2 = new Thread(t);

//开启线程

target.start();

target2.start();

}

//1，实现Runnable接口，重写run()

class MyThread implements Runnable{

@Override

public void run() {

for (int i = 0; i < 10; i++) {

System.out.println(Thread.currentThread().getName()+" "+i);

}

执行结果：

Thread-0

Thread-2

Thread-1

Thread-5

Thread-8

Thread-6

Thread-7

Thread-4

Thread-3

Thread-9

注意：可以看到执行顺序是乱的，我们已经知道start()方法只是通知操作系统线程就绪，具体什么时间执行，操作系统来决定，我们JVM已经控制不了了。这就是乱序的原因，也是正常的。

1.5.4 比较

方式	优点	缺点
Thread	编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。	线程类已经继承了Thread类，所以不能再继承其他父类
Runnable	线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。	编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
Callable	Runnable规定（重写）的方法是run() Callable规定（重写）的方法是call() Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。 Call方法可以抛出异常，run方法不可以。运行Callable任务可以拿到一个Future对象，表示异步计算的结果。	存取其他项慢
Pool	线程池可以创建固定大小，这样无需反复创建线程对象，线程是比较耗费资源的资源同时线程不会一直无界的创建下去，拖慢系统，	编程繁琐，难以理解

1.6 售票案例

设计4个售票窗口，总计售票100张。

用多线程的程序设计并写出代码。

1.6.1 方案1：继承Thread

package seday13new;

public class Test3 {

public static void main(String[] args) {

Ticket t = new Ticket();

Ticket t2 = new Ticket();

Ticket t3 = new Ticket();

Ticket t4 = new Ticket();

//问题：票好像卖重复了，同一张票卖了好多次...

t.start();

t2.start();

t3.start();

t4.start();

}

class Ticket extends Thread {

//卖了200张票，变成static的

static private int tic = 100;

@Override

public void run() {

while (true) {

//tic=1时，谁都可以进来,t t2 t3 t4

if (tic > 0) {

try {

//t t2 t3 t4都睡了

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

//t醒了，tic--=1，tic=0;

//t2醒了，tic--=0，tic=-1;

//t3醒了，tic--=-1，tic=-2;

//t4醒了，tic--=-2，tic=-3;

System.out.println(tic--);

}

1.6.2 方案2：实现Runnable

package seday13new;

public class Test4 {

public static void main(String[] args) {

//只创建一次，就100张票

Ticket2 t = new Ticket2();

Thread target = new Thread(t,"窗口1");

Thread target2 = new Thread(t,"窗口2");

Thread target3 = new Thread(t,"窗口3");

Thread target4 = new Thread(t,"窗口4");

target.start();

target2.start();

target3.start();

target4.start();

}

class Ticket2 implements Runnable{

private int tickets=100;

@Override

public void run() {

while(true) {

if(tickets >0) {

try {

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+tic--);

}

1.6.3 问题

1、每次创建线程对象，都会生成一个tickets变量值是100，创建4次对象就生成了400张票了。不符合需求，怎么解决呢？能不能把tickets变量在每个对象间共享，就保证多少个对象都是卖这100张票。-- 用静态修饰

2、产生超卖，-1张、-2张。

3、产生重卖，同一张票卖给多人。

4、多线程安全问题是如何出现的？常见情况是由于线程的随机性+访问延迟。

5、以后如何判断程序有没有线程安全问题？在多线程程序中+有共享数据+多条语句操作共享数据。

package cn.tedu.collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

//测试集合工具类collections
public class Test1_Collections {

   public static void main(String[] args) {
       //创建List集合，并添加元素
       List<Integer> list=new ArrayList<>();
       list.add(1);
       list.add(7);
       list.add(9);
       list.add(3);
       System.out.println(list);
       Collections.addAll(list, 2,4,6,8);//向指定集合一次性添加多个数据
       System.out.println(list);
       System.out.println(Collections.max(list));//获取list集合中的最大值
       System.out.println(Collections.min(list));//获取list集合中的最小值

       Collections.reverse(list);//指定的list集合数据进行反转[8, 6, 4, 2, 3, 9, 7, 1]
       System.out.println(list);

       Collections.sort(list);//指定的list集合数据进行排序[1, 2, 3, 4, 6, 7, 8, 9]
       System.out.println(list);

       Collections.swap(list, 1, 6);//把list中，指定下标位置的两个元素进行交换
       System.out.println(list);//[1, 8, 3, 4, 6, 7, 2, 9]


   }

}

package cn.tedu.thread;
//测试多线程编程
public class Test2_Thread {

   public static void main(String[] args) {
       //4.让多线程启动起来
       MyThread t1 = new MyThread();//新建状态
       MyThread t2 = new MyThread();

       //6.设置线程名称
       t1.setName("灭霸");
       t2.setName("猪猪侠");
       /*把业务当做普通的方法执行，没有多线程抢占效果
       * */
       //如何让run()执行起来？
       //多线程程序
       //5.启动线程
       t1.start();//可运行状态--等待cpu调度
       t2.start();

   }

}

//1.模拟多线程编程-extends Thread
class MyThread extends Thread{
   //2.把所有业务，写在重写的run()里
   @Override
   public void run() {//运行状态
       //3.输出100此线程名称
       for (int i = 0; i < 100; i++) {
           System.out.println(getId()+super.getName()+"==="+i);
       }
   }//结束状态/终止状态
}

package cn.tedu.thread;
//测试Runnable
public class Test3_Runnable {

   public static void main(String[] args) {
       //5.让线程启动起来
       MyRunnable target = new MyRunnable();
       Thread t1 = new Thread(target);
       Thread t2 = new Thread(target);
       t1.start();
       t2.start();

}

}
//1.模拟多线程编程implements Runnable
class MyRunnable implements Runnable{
   //2.实现Runnable接口，就要把接口里的所有抽象方法都重写，否则就包含抽象方法
   //3.在多线程中，需要把所有的业务统一放在run()里
   @Override
   public void run() {
       // 打印100次线程名称
       for (int i = 0; i < 100; i++) {
           /*Thread类里的静态currentThread()返回当前正在执行任务
           * 的线程对象的引用
           * */
           System.out.println(Thread.currentThread().getName()+"==="+i);
       }

   }
}

package cn.tedu.thread;
//模拟多线程售票--继承Thread
public class Test4_Tickets {

public static void main(String[] args) {
//3.测试启动线程

       MyTickets t1 = new MyTickets();
       t1.start();
       MyTickets t2 = new MyTickets();
       t2.start();
       MyTickets t3 = new MyTickets();
       t3.start();
       MyTickets t4 = new MyTickets();
       t4.start();

       //问题1：总共需要卖出100张票，但是，现在却卖出了400张票，为什么？
       /*成员变量tickets，每次实例化时，都会跟着对象初始化一次，
       * 4个对象就各自卖自己的1001张票
       *
       * 解决方案：
       * 把共享资源tickets加static修饰，变成全局唯一全局共享
       *
       * 目前，来看，程序中的4个线程完美的配合着卖了1001张票
       * 但是，数据最终有没有安全隐患--让程序休眠一会
       * */
   }

}

//1.创建多线程类extends Thread
class MyTickets extends Thread{
   //让4个窗口一起卖出1001张票
   //定义变量，记录初始值
   static int tickets = 100 ;

   //2.开始卖票--把业务放入run()
   @Override
   public void run() {
       //一直卖票，卖完结束
       while(true) {//死循环--配置设置好出口
           synchronized (MyTickets.class) {
               if(tickets>0) {
                   //5.验证多线程中，数据是否安全，都要接受这次考验
                   /*问题2：超卖：卖出了0号票，甚至-1号票
                   * 问题3：重卖：同一张票卖给了好几个人
                   * */
                   try {
                       Thread.sleep(10);
                   } catch (InterruptedException e) {

                       e.printStackTrace();
                   }
                   //3.打印线程名称

                   System.out.println(getName()+"====="+tickets--);
               }else {
                   break;//合理的出口
               }
           }


       }
   }
}

package cn.tedu.thread;
//模拟多线程售票---实现Rannable
public class Test5_Tickets2 {

public static void main(String[] args) {
//4.测试--让线程启动起来

MyTickets2 target = new MyTickets2();
Thread t1 = new Thread(target);
Thread t2 = new Thread(target);
Thread t3 = new Thread(target);
Thread t4 = new Thread(target);
t1.start();
t2.start();
t3.start();
t4.start();

}

//1.创建多线程类--implements Runnable
class MyTickets2 implements Runnable{
//--需求：让四个窗口，一起卖100张票
int tickets=100;

// Object obj =new Object();
String s1="jack";
//3.同步锁也可以直接锁方法，默认用的锁对象是this
/*目前程序中，由于在多线程编程中，出现了对个线程抢占资源造成的数据错乱
加锁来解决数据安全隐患问题，考虑以下两个问题
1.锁的位置：把会有问题的代码锁起来，从问题源头开始，到结束为止，都包起来
2.锁的对象:当使用锁，把代码块锁起来后，需要考虑锁对象是谁？可以是任意对象，只要是同一个对象就行
3.同步锁也可以直接锁方法，默认是用的锁对象this
4.如果共享资源是一个静态资源，锁对象必须是类名.class
* */
@Override
/*t1 t2 t3 t4都准备开始卖票
* * */
public void run() {
//一直卖票，卖完结束
while(true) {//死循环--配置设置好出口
synchronized (this){//从头到尾都只有一个对象
if(tickets>0) {
try {
//5.验证多线程中，数据是否安全，都要接受这次考验
/*问题1：超卖：卖出了0号票，甚至-1号票
* 问题3：重卖：同一张票卖给了好几个人
* */
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//3.打印线程名称 Thread.currentThread() 返回当前正在执行任务的线程的对象的引用
System.out.println(Thread.currentThread().getName()+"====="+tickets--);
}else {
break;//合理的出口
}
}

}

}
}

abu1216

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
1 Day16--多线程1

1.1进程1.1.1概念就是正在运行的程序。也就是代表了程序锁占用的内存区域。1.1.2特点l独立性：进程是系统中独立存在的实体，它可以拥有自己的独立的资源，每一个进程都拥有自己私有的地址空间。在没有经过进程本身允许的情况下，一个用户进程不可以直接访问其他进程的地址空间。l动态性：进程与程序的区别在于，程序只是一个静态的指令集合，而进程是一个正在系统中活动的指令集合。在进程中加入了时间的概念，进程具有自己的生命周期和各种不同的状态，这些概念在程序中都是不具...
复制链接

扫一扫