2021-3-5线程和多线程

最新推荐文章于 2024-01-25 11:27:18 发布

小高写BUG

最新推荐文章于 2024-01-25 11:27:18 发布

阅读量482

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/gao1213977085/article/details/114419759

版权

Java基础专栏收录该内容

25 篇文章 0 订阅

订阅专栏

#线程和多线程

测试方向基础课，一部分就是讲java

1.java(SE)多线程和网络编程什么是性能测试？性能测试怎么做？

原理：以多线程的方式，基于协议的，模拟用户场景的测试

不是基于界面的（基于界面的是UI测试）

2、java(EE) Servlet 、JDBC（了解开发体系）MVC（分层结构）、需要了解开发体系是怎么样的

1.类是怎么封装的   属性和方法
2、数据类型
3.属性赋值，setter\getter、构造方法
4.流
引用、对象、容器

多线程

程序、进程、线程

线程的引用场景

程序是一段静态的代码，是应用软件执行的蓝本

package ThreadDemo1;

public class Demo1 {
	//Alt +/
    
   //单线程   主线程
	public static void main(String[] args) throws InterruptedException {
        
        System.out.println(Thread.currentThread().getName());   //main
		Thread.sleep(5000);//睡眠5秒钟
		System.out.println("hello");
	}
}

进程是程序的一次动态执行的过程，他对应了从代码加载、执行、至完毕的一个完整的过程

一个应用程序一个进程

独立功能的程序

通过多个线程占据系统资源

进程之间数据状态完全独立

线程是比进程更小的执行单位，

一个程序在运行过程中，产生一个进程，

一个进程可以有多个线程

执行程序的最小单元

占用CPU的基本单位

线程间共享一块内存空间

java中的线程

每个java程序都有一个默认线程

System.out.println(Thread.currentThread().getId());//1

当JVM加载代码发现main方法之后，就会立即启动一个线程，这个线程为主线程

主线程的特点

是产生其他子线程的线程

不一定是最后完成执行的线程

如果main方法中没有创建其他的线程，那么当main方法执行完最后一个语句，JVM就会结束java应用程序----单线程

多线程的优势

减轻编写交互频繁、涉及面多的程序的困难

程序吞吐量会得到改善

由多个处理器的系统，可以并发运行不同的线程

同时执行是人的错觉

应用场合

迅雷下载

想要同时处理多件事：单线程处理不了的，必须使用多线程

多线程分解大任务:多线程更快

生命周期：

新建就绪运行阻塞死亡

新建：new —>就绪

、就绪： start----- 运行状态

、运行 ----- 死亡状态

运行-----时间片用完了----就绪

运行-----sleep wait，等待用户输入-------阻塞-------条件具备了------就绪

、阻塞

和死亡。

线程状态介绍

新建状态：线程对象已经创建

两种创建线程的方法

#####继承Thread类

重写run（）方法

new一个线程对象

调用对象的start()启动线程

实现Runnable接口

实现

1.创建线程子类继承Thread类

2.重写run（）方法

3.在main方法中new一个线程类的对象

4.调用start（）,启动子线程。

package ThreadDemo1;

class MyThread extends Thread {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i = 0;i<101;i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("bbbbb");
		}
		super.run();
	}
}
public class TreadDemo {
	public static void main(String[] args) throws InterruptedException {
		//使用new处于新建状态
		MyThread thread1 = new MyThread();
		//star处于就绪状态，底层就会自动调用run方法
		thread1.start();
		for(int i = 0;i<100;i++) {
			Thread.sleep(3000);
			System.out.println("aaaaa");
		}
	}

}

ps：调用start方法底层

第二种直接创建RUNABLE接口(推荐)

package ThreadDemo1;
class MyRunnable1 implements Runnable{
/*
 * (non-Javadoc)
 * @see java.lang.Runnable#run()
 * 1.创建子类接口Runnable
 * 2.重写run()
 * 3.创建子类对象
 * 4.创建线程类Thread对象，*把子类对象最为构造参数传递
 * 5.调用线程对象start();启动线程
 */
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i = 0;i<101;i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("bbbbb");
		}

	}
	
}

public class RunableDemo {
	public static void main(String[] args) {
		MyRunnable1 my_runnable = new MyRunnable1();
		Thread myThread = new Thread(my_runnable);
		myThread.start();
		
	}
}

package ThreadDemo1;

class MyThread extends Thread {
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i = 0;i<101;i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
            this.getPriority();//优先级
			System.out.println("修改前的名称"+this.getName());
			this.setName("Thread-0305");
			System.out.println("修改后的名称"+this.getName());
			System.out.println("bbbbb");
		}
		super.run();
	}
}
public class TreadDemo {
	public static void main(String[] args) throws InterruptedException {
		//使用new处于新建状态
		MyThread thread1 = new MyThread();
		//star处于就绪状态
		thread1.start();//        
        
        //一个线程只能启动一次 
        //区分run()方法。
		for(int i = 0;i<100;i++) {
			Thread.sleep(3000);
			System.out.println("aaaaa");
		}
	}

}

一个线程run方法执行结束后。该线程结束

一个线程只能被启动一次

####Thread方法

run()方法的调用只是普通方法的调用

线程的调度是JVM的一部分，在一个CPU机器上，一次只能运行一个线程。JVM

start()是启动线程

run（）是调用

sleep单位是毫秒线程暂停执行，线程处于哪个状态？？？？阻塞再转换就绪

Thread.currentThread().getName();
System.out.println("启动之前的状态"+thread1.isAlive());

myThread.setPriority(8);
//制定优先级的变化

myThread.join(3000);//执行3秒后我再执行

myThread.stop();

阻止线程执行的方法

线程睡眠、线程等待、线程阻塞。

线程睡眠

Java中通过Thread的静态方法sleep来实现线程的睡眠。

线程睡眠是帮助其他线程获得运行的最后方法

到期自动苏醒，并返回到可运行状态，不是运行状态

线程的优先级

1到10默认优先级是5

都具有相同优先级时由两种可能

1.选一个线程运行

2.事件分片

线程让步的问题

myThread.yield();//线程让步，暂停当前线程，让同等优先级的线程运行。
join();//改变线程的执行顺序，该线程运行结束后

线程阻塞

在线程A中调用B.join()。让一个线程A“加入”到线程B的尾部。

线程内用this

要实现卖票怎么实现卖票的机制，实现(三个)多窗口的卖票？

Runnable来实现卖票?

package ThreadDemo1;
class My12306Runnable implements Runnable{

	private int ticketNum = 10;
	
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(this.ticketNum > 0) {
			this.ticketNum--;
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+":"+this.ticketNum);
		}
		
	}
	
}

public class My12306 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		My12306Runnable my_runnable = new My12306Runnable();
		new Thread(my_runnable,"窗口1").start();
		new Thread(my_runnable,"窗口2").start();
		new Thread(my_runnable,"窗口3").start();

	}

}

5/6/100 把票的数量传给对象

package ThreadDemo1;
class My12306Runnable implements Runnable{

	private int ticketNum;
	public My12306Runnable(int ticketNum) {
		this.ticketNum =ticketNum;
	}
	
	
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(this.ticketNum > 0) {
			this.ticketNum--;
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+":"+this.ticketNum);
		}
		
	}
	
}

public class My12306 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		My12306Runnable my_runnable = new My12306Runnable(8);
		new Thread(my_runnable,"窗口1").start();
		new Thread(my_runnable,"窗口2").start();
		new Thread(my_runnable,"窗口3").start();

	}

}