首页 > 代码库 > 多线程(一)

多线程(一)

这边来谈谈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这个锁,执行同步代码块中的内容

}

}

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

多线程(一)