多线程

Posted 2020-09-18

这边来谈谈java中，我对对多线程的理解

在了解多线程前，先说说进程。

进程就是正在运行的应用程序。  当你打开任务管理器的时候，你就会发现很多的进程。

而我们要说的线程，就是依赖于进程而存在的，一个进程可以开启多个线程。

Thread类

说到线程，就必须来说说Thread类。

Thread类是说有线程的父类。具体请参见api

线程的创建以及执行（图解如下）

继承Thread类，或者实现rennable接口。
当继承了父类后，需要重写父类的run方法，这个run方法里面就写你要执行的代码，当这个线程启动的时候，就会执行你重写的run方法里面的内容。上边的图run里面写的是一个for循环，输出的是一到一百。

线程启动：start方法即可实现。
代码实现：开启线程，并启动，输出结果

public class MyThread extends Thread{
	//1.继承Thread类
	//2.重写run方法，重写run方法中的代码之后，当我们启动了这个线程之后，我们的这个线程就会执行run方法中的代码
	public class MyThread extends Thread{
	//1.继承Thread类
	//2.重写run方法，重写run方法中的代码之后，当我们启动了这个线程之后，我们的这个线程就会执行run方法中的代码
	@Override
	public void run() {
		//需求：开启该线程之后，执行一个for循环
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
		}
	}
	
	//在测试类中启动，来看输出。
	//代码实现
	public class Test {
	public static void main(String[] args) {
		//只要我们创建了一个线程对象，并且启动该线程的实例，我们就相当于开启了一///个线程
		MyThread mt = new MyThread();
		mt.start();//1.开启了一个线程   2.让开启的这个线程执行他对应的类中的run方//法
		
		//在次创建一个子线程，并开启这个子线程执行他的run方法
		MyThread mt2 = new MyThread();
		mt2.start();
		
	}
	
	最终输出的是我们在run方法里写的for循环。
	
	
接下来我们用第二种方法，实现一个runnable接，并重写run方法
public class MyThread implements Runnable{
	@Override
	public void run() {
		//启动该线程对象之后，需要执行的代码
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
		}	
	}

}	
public class MyThread implements Runnable{
	@Override
	public void run() {
		//启动该线程对象之后，需要执行的代码
		for (int i = 0; i < 10; i++) {
			System.out.println(i);
		}	
	}

}

public class Test {
	public static void main(String[] args) {
		//创建Mythread对象
		MyThread mt = new MyThread();
		Thread t1 = new Thread(mt);
		t1.start();
		
		
	}

}	
这就是线程的创建和启动


	线程的调度和控制
		线程休眠(Thread.sleep(毫秒值))
		线程名称（setName(),getName();）
		线程的调度及优先级setPriority(10)（注意默认值是5，区间在1-10之间）
		什么叫线程优先级：说白了就是设置你抢占cpu执行权抢占到的概率
		
	
			MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		MyThread t3 = new MyThread();
		
		//给三个线程设置姓名
		t1.setName("刘备");
		t2.setName("张飞");
		t3.setName("关羽");
		
		//设置线程的优先级
		//线程的调度及优先级setPriority(10)（注意默认值是5，区间在1-10之间）
		//t1.setPriority(100);//设置的区间必须在1-10之间
		t1.setPriority(10);
		
		//开启线程
		t1.start();
		t2.start();
		t3.start();
		
		
	//共有100张票,将ticket改为静态之后，被类的所有对象所共享
	static int ticket = 100;
	
	@Override
	public void run() {
		//用一个while true循环模拟三个窗口一直处于打开的状态
		while (true) {
			//只有当ticket>0的时候，才可以出售票
			if (ticket>0) {
		System.out.println(getName()+"正在出售第："+ticket--+"张票");
			}
		}
	}
		
		
	public static void main(String[] args) {
		//创建三个线程模拟三个售票窗口
		MyThread mt1 = new MyThread();
		MyThread mt2 = new MyThread();
		MyThread mt3 = new MyThread();
		
		//给线程设置名称
		mt1.setName("窗口一");
		mt2.setName("窗口二");
		mt3.setName("窗口三");
		
		//启动线程，开启售票
		mt1.start();
		mt2.start();
		mt3.start();
		
	}
		以上代码是一个售票案例，是一个多线程的案例。
		
		
	这里说到cpu的执行权。下图简单说说，执行权和执行。		

这是那个案例的输出结果，在之后我们会谈到线程不安全性问题。

这里说几点：执行权的抢占是随机的，谁抢到就执行谁，可以通过sleep来验证（详见java相关\第十五天代码+资料）

在使用runnable实现售票案例的时候，在线程睡一会之后，会出现线程安全性问题。

如何解决多线程安全问题

*线程安全执行效率就低

A:同步代码块（测试不是同一个锁的情况，测试是同一个锁的情况）

synchronized(对象) {

需要被同步的代码。

}

需求：1.测试不是同一把锁的时候线程安全吗？ 2.如果是同一把锁线程安全吗？

两个问题：1.对象是什么 ？

 答：任意对象 ，相当于是一把锁，只要线程进去就把锁锁上

 2.需要同步的代码？

 答：被线程执行的代码

锁对象问题

a:同步代码

块（定义一个抽象类，里面专门定义一个锁）

任意对象

b:同步方法（仅适用于实现runable接口）

public synchronized void sellTicket(){同步代码}

this

静态同步方法

类的字节码对象

public static synchronized void sellTicket() {

需要同步的代码

}

    

public class MyThread implements Runnable{
//定义100张票
int ticket = 100;
Object obj = new Object();
@Override
public void run() {
while (true) {
//同步代码块
//synchronized (new Object()) {//t1,t2,t3三个线程不共享同一把锁每个线程都有自己的议案锁
synchronized (obj) {//这样3个线程才可以共享同一把锁
if (ticket>0) {
//考虑到实际的生活中，我们需要给每一个线程加入一定的延迟，模拟一下这种效果
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第："+ticket--+"张票");
}

//当被同步的代码执行完毕之后，t1手里拿着的obj这个锁才会被释放，

//t1,t2,t3重新抢占cpu的执行权，谁抢到了继续拿着obj这个锁，执行同步代码块中的内容

}

}

总之，要解决线程安全性问题，就是上边的方法，关于线程，有好多知识点需要巩固，当然有些东西会在下一次的文章中写（多线程二）。