多线程(Thread)

最新推荐文章于 2024-07-17 23:30:09 发布

**瑱

最新推荐文章于 2024-07-17 23:30:09 发布

阅读量1.6k

点赞数

分类专栏： JavaOOP

本文链接：https://blog.csdn.net/CDZAllier/article/details/97896663

版权

JavaOOP 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

程序：

是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态概念。

进程：

是程序在处理机上的一次执行过程，它是一个动态的概念。（独立运行的程序，也就是处理机执行的过程）

进程的三种状态： 1)就绪状态(Ready) 2)运行状态(Running) 3)阻塞状态(Blocked)

线程：（java是多线程）

线程是进程的划分，（也就是进程中的一个执行路径，共享一个空间，可以自由切换，称并发执行）

单线程：一个进程只有一个线程（一个进程中最少有一个线程）

并行：

指多个任务同时运行（多个CPU）

并发：

多个任务同时请求运行，处理器一次只能接受一个任务（所有任务轮流执行，由于CPU运行时间较短，感觉在同时运行）

线程的使用（两种方式）

方式一：

由类直接继承Thread类，并重写run方法

package com.cdz.jicheng;//包
public class MThread {  //类名
	public static void main(String[] args) {
		//继承线程类
		Xthread x=new Xthread();
		x.start();//调用进程，启动线程，准备就绪
	
	}	
}
//线程使用一：继承
class Xthread extends Thread{
	@Override
	public void run() {//线程必须重写该方法
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+"--"+i);//拿到线程名			
		}		
	}	
}

方式二：

实现Runnable类，并重写run方法（常用的）

package com.cdz.shixian;//包
public class MThread {  //类名
	public static void main(String[] args) {
		//实现线程类
		MyRunnable x=new MyRunnable();
		Thread t=new Thread(x);	
		t.start();//启动线程，准备就绪	
	}	
}
//线程使用二：实现（这个是最常用的）
class MyRunnable  implements Runnable{
	@Override
	public void run() {//线程必须重写该方法
		for(int i=0;i<10;i++){
			System.out.println(Thread.currentThread().getName()+"--"+i);//拿到线程名			
		}		
	}	
}

方法：

1. Thread . currentThread() 返回对当前正在执行的线程对象的引用。

2. start();启动线程，准备就绪

3. sleep(millis);线程休眠（使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），释放CPU的时间片，具体取决于系统定时器和调度程序的精度和准确性。线程不会丢失任何显示器的所有权。）;millis,时间毫秒为单位

4. join();加入线程

5. setDaemonl(true);设置为守护线程（默认false,也就是用户线程，可以不用写）

6. getid();获取线程标识

7. setName();线程改名

8. getName();获取线程的名字

9. isAlive();测试线程是否为活动状态

（这些线程的方法大多数用在多线程的使用）

多线程

1. 多线程是没有顺序的执行，谁抢到谁执行（不管是主线程还是其他线程）

2. 线程休眠：

package com.cdz.shixian;//包
public class MThread {  //类名
	public static void main(String[] args) {
		//实现线程类
		XRunnable x=new XRunnable();
		Thread t1=new Thread(x);	//线程一
		t1.start();//启动线程1，准备就绪	
		
		YRunnable y=new YRunnable();
		Thread t2=new Thread(y);//线程二	
		t2.start();//启动线程2，准备就绪	
		
	}	
}
//线程：实现（这个是最常用的）
class XRunnable  implements Runnable{
	@Override
	public  void run() {//线程必须重写该方法
		for(int i=0;i<50;i++){                     //拿到线程名	
			System.out.println(Thread.currentThread().getName()+"--"+i);
			try {
				Thread.sleep(500);//抛异常，也就是把自己的时间让给别人去执行，这里休眠500毫秒
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
		}		
	}	
}
//线程：实现（这个是最常用的）
class YRunnable  implements Runnable{
	@Override
	public  void run() {//线程必须重写该方法
		for(int i=0;i<50;i++){                     //拿到线程名	
			System.out.println(Thread.currentThread().getName()+"--"+i);					
		}		
	}	
}

3. 加入线程

package com.cdz.xiancheng;

public class MThread {

	public static void main(String[] args) {			
		//实现线类
		Yrunnable y=new Yrunnable();
		//多线程调用
		Thread xy=new Thread(y);
		xy.start();
		for(int i=0;i<50;i++){
			System.out.println(Thread.currentThread().getName()+"--"+i);//主线程
			if(i==20){
				try {
					xy.join();//使xy线程加入进来
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}	
}

//线程使用二：实现
class Yrunnable implements Runnable{
	@Override
	public void run() {
		for(int j=0;j<50;j++){	
			System.out.println(Thread.currentThread().getName()+"--"+j);						
		}				
	}	
}

原理：跑完主线程的20个，加入xy线程，xy线程走完后再执行主线程

4. 中断线程

①interrupt方法（使用该方法时，容易抛异常，这里不作介绍）

②自定义中断线程（也就是定义一个变量开关）

package com.cdz.self_defined;//包

public class MThread { // 类名
	public static void main(String[] args) {
		MyRunnable mr = new MyRunnable();
		Thread tr1 = new Thread(mr);//tr1线程
		tr1.start();

		for (int i = 1; i <= 50; i++) {//先执行主线程里的
			System.out.println(Thread.currentThread().getName() + "---" + i);
			if (i == 20) {//这里进行中断处理赋值
				mr.flag = false;				
			}
			try {
				Thread.sleep(300);//执行一个等待300毫秒，在等待的过程中去执行其它线程
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
class MyRunnable implements Runnable {
	public Boolean flag = true; //定义的公共的变量，进行中断
	@Override
	public void run() {
		while (flag) {
			int i = 1;
			System.out.println(Thread.currentThread().getName() + "---" + i);
			try {
				Thread.sleep(500);//线程由于是抢来执行的，如果没有这句话，就会一直执行该线程
					//执行一个等待500毫秒，在等待的过程中去执行其它线程
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			i++;
		}
	}
}

5. 守护线程

package com.cdz.shouhu;

public class MThread {

	public static void main(String[] args) {
		
		MyRunnable mr=new MyRunnable();
		Thread th=new Thread(mr);
		th.setDaemon(true);//th此时为守护线程，线程可以分为用户线程和守护线程，当进程中没有用户线程，JVM会退出。
		th.start();

		for(int i=1;i<=50;i++){//这个主线程为用户线程
			System.out.println(Thread.currentThread().getName()+"--"+i);
		}
	}	
}
class MyRunnable  implements Runnable{
	@Override
	public  void run() {//线程必须重写该方法
		for(int i=0;i<50;i++){                     //拿到线程名	
			System.out.println(Thread.currentThread().getName()+"--"+i);					
		}		
	}	
}

注意：这个守护线程有几种情况，①守护线程在用户线程前执行完②守护线程没有执行③守护线程在用户线程后执行，但不会执行完（为什么，我也不清楚，如有人知道请告知。上面i的值越大，更能体现）

6. 线程同步

关键字：synchronized

方式一：代码块

package com.cdz.tongbu;
public class MThread {
	public static void main(String[] args) {		
		Yrunnable y=new Yrunnable();
		//多线程调用
		Thread xy1=new Thread(y);
		xy1.start();//线程1
		Thread xy2=new Thread(y);
		xy2.start();//线程2
	}	
}
//1.
class Yrunnable implements Runnable{
	private int i=0;
	@Override
	public void run() {
		synchronized(this){//同步代码块,也就是值在随时更新
			for(;i<50;i++){
				System.out.println(i);
			}		
		}		
	}	
}

方式二：方法

package com.cdz.tongbu;
public class MThread {
	public static void main(String[] args) {		
		Yrunnable y=new Yrunnable();
		//多线程调用
		Thread xy1=new Thread(y);
		xy1.start();//线程1
		Thread xy2=new Thread(y);
		xy2.start();//线程2
	}	
}

//2.
class Yrunnable implements Runnable{
	public synchronized void r(){
		for(;i<50;i++){
			System.out.println(i);
		}
	}
	private int i=0;
	@Override
	public void run() {
		r();		
	}	
}