java多线程基础概念

java多线程基础概念

大家好,我是架构君,一个会写代码吟诗的架构师。今天说一说java多线程基础概念,希望能够帮助大家进步!!!

概念:

进程是所有线程的集合,进程是执行中的程序,进程中一定有一个主线程(main方法)。
线程是一条执行路径,或者说是独立的执行单元。
在这里插入图片描述

多线程特性:
1.原子性:即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断,要么就都不执行。
2.可见性:是指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。
3.有序性:即程序执行的顺序按照代码的先后顺序执行。

注意:它提高执行效率,并且线程间互不影响。但是它不是通过提升带宽只是提高程序的执行效率

多线程的应用:多线程下载,QQ,爬虫,前端ajax,分布式job(同一时间执行多个任务调度)

一、创建多线程的方法

  • 1.继承thread
  • 2.实现runable接口
  • 3.匿名内部类
  • 4.callable(有future返回值)
  • 5.线程池创建

1.1创建例子

1.1.1继承thread

class CreateThread extends Thread {
	// run方法中编写 多线程需要执行的代码
	publicvoid run() {
		for (inti = 0; i< 10; i++) {
			System.out.println("i:" + i);
		}
	}
}
publicclass ThreadDemo {

	publicstaticvoid main(String[] args) {
		System.out.println("-----多线程创建开始-----");
		// 1.创建一个线程
		CreateThread createThread = new CreateThread();
		// 2.开始执行线程 注意 开启线程不是调用run方法,而是start方法
		System.out.println("-----多线程创建启动-----");
		createThread.start();
		System.out.println("-----多线程创建结束-----");
	}

}

在这里插入图片描述
调用start方法后,代码并没有从上往下执行,而是有一条新的执行分之。
注意:画图演示多线程不同执行路径。

在这里插入图片描述

1.1.2第二种实现Runnable接口,重写run方法

class CreateRunnable implements Runnable {

	@Override
	publicvoid run() {
		for (inti = 0; i< 10; i++) {
			System.out.println("i:" + i);
		}
	}

}


publicclass ThreadDemo2 {
	publicstaticvoid main(String[] args) {
		System.out.println("-----多线程创建开始-----");
		// 1.创建一个线程
		CreateRunnable createThread = new CreateRunnable();
		// 2.开始执行线程 注意 开启线程不是调用run方法,而是start方法
		System.out.println("-----多线程创建启动-----");
		Thread thread = new Thread(createThread);
		thread.start();
		System.out.println("-----多线程创建结束-----");
	}
}

1.1.3 第三种使用匿名内部类方式

 System.out.println("-----多线程创建开始-----");
		 Thread thread = new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i< 10; i++) {
					System.out.println("i:" + i);
				}
			}
		});
		 thread.start();
		 System.out.println("-----多线程创建结束-----");

使用继承Thread类还是使用实现Runnable接口好?

使用实现实现Runnable接口好,原因实现了接口还可以继续继承,继承了类不能再继承。

启动线程是使用调用start方法还是run方法?

开始执行线程 注意 开启线程不是调用run方法,而是start方法
调用run知识使用实例调用方法。

1.2获取线程对象以及名称

1.2.1常用线程api方法

start() 启动线程
currentThread() 获取当前线程对象
getID() 获取当前线程ID Thread-编号 该编号从0开始
getName() 获取当前线程名称
sleep(long mill) 休眠线程
Stop() 停止线程,

1.2.2 常用线程构造函数

Thread() 分配一个新的 Thread 对象
Thread(String name) 分配一个新的 Thread对象,具有指定的 name正如其名。
Thread(Runable r) 分配一个新的 Thread对象
Thread(Runable r, String name) 分配一个新的 Thread对象

1.3 守护线程

Java中有两种线程,一种是用户线程,另一种是守护线程。
用户线程是指用户自定义创建的线程,主线程停止,用户线程不会停止
守护线程当进程不存在或主线程停止,守护线程也会被停止。
使用setDaemon(true)方法设置为守护线程
在这里插入图片描述

public class DaemonThread {

	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(100);
					} catch (Exception e) {
						// TODO: handle exception
					}
					System.out.println("我是子线程...");
				}
			}
		});
		thread.setDaemon(true);
		thread.start();
		for (int i = 0; i < 10; i++) {
			try {
				Thread.sleep(100);
			} catch (Exception e) {

			}
			System.out.println("我是主线程");
		}
		System.out.println("主线程执行完毕!");
	}

}

1.垃圾回收也是一个线程并且是守护线程:gc线程,因此当main方法结束之后他就不再回收了
2.建议使用继承runable接口的实现方法:a.因为接口可以多实现而继承只能单继承。b.因为java是面向接口编程!
3.只有start是开启线程。调用run方法并没有开启线程,run只是调用了这个方法而已

二、线程状态

在这里插入图片描述

  • 新建状态
    当用new操作符创建一个线程时, 例如new Thread®,线程还没有开始运行,此时线程处在新建状态。 当一个线程处于新生状态时,程序还没有开始运行线程中的代码

  • 就绪状态
    一个新创建的线程并不自动开始运行,要执行线程,必须调用线程的start()方法。当线程对象调用start()方法即启动了线程,start()方法创建线程运行的系统资源,并调度线程运行run()方法。当start()方法返回后,线程就处于就绪状态。
    处于就绪状态的线程并不一定立即运行run()方法,线程还必须同其他线程竞争CPU时间,只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中,不可能同时运行多个线程,一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

  • 运行状态
    当线程获得CPU时间后,它才进入运行状态,真正开始执行run()方法.

  • 阻塞状态
    线程运行过程中,可能由于各种原因进入阻塞状态:
    1>线程通过调用sleep方法进入睡眠状态;
    2>线程调用一个在I/O上被阻塞的操作,即该操作在输入输出操作完成之前不会返回到它的调用者;
    3>线程试图得到一个锁,而该锁正被其他线程持有;
    4>线程在等待某个触发条件;

  • 死亡状态
    有两个原因会导致线程死亡:

    1. run方法正常退出而自然死亡,
    2. 一个未捕获的异常终止了run方法而使线程猝死。
      为了确定线程在当前是否存活着(就是要么是可运行的,要么是被阻塞了),需要使用isAlive方法。如果是可运行或被阻塞,这个方法返回true; 如果线程仍旧是new状态且不是可运行的, 或者线程死亡了,则返回false.

2.1 join方法

join作用是让其他线程变为等待, t1.join();// 让其他线程变为等待,直到当前t1线程执行完毕,才释放。
thread.Join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法,直到线程A执行完毕后,才会继续执行线程B。

创建一个线程,子线程执行完毕后,主线程才能执行。

class JoinThread implements Runnable {

	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + "---i:" + i);
		}
	}
}


public class JoinThreadDemo {

	public static void main(String[] args) {
		JoinThread joinThread = new JoinThread();
		Thread t1 = new Thread(joinThread);
		Thread t2 = new Thread(joinThread);
		t1.start();
		t2.start();
		try {
       //其他线程变为等待状态,等t1线程执行完成之后才能执行join方法。
			t1.join();
		} catch (Exception e) {

		}
		for (int i = 0; i < 100; i++) {
			System.out.println("main ---i:" + i);
		}
	}

}

2.2 优先级

现代操作系统基本采用时分的形式调度运行的线程,线程分配得到的时间片的多少决定了线程使用处理器资源的多少,也对应了线程优先级这个概念。在JAVA线程中,通过一个int priority来控制优先级,范围为1-10,其中10最高,默认值为5。下面是源码(基于1.8)中关于priority的一些量和方法。

class PrioritytThread implements Runnable {

	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().toString() + "---i:" + i);
		}
	}
}


public class ThreadDemo4 {

	public static void main(String[] args) {
		PrioritytThread prioritytThread = new PrioritytThread();
		Thread t1 = new Thread(prioritytThread);
		Thread t2 = new Thread(prioritytThread);
		t1.start();
		// 注意设置了优先级, 不代表每次都一定会被执行。 只是CPU调度会有限分配
		t1.setPriority(10);
		t2.start();
		
	}

}

面试相关

1.现在有T1、T2、T3三个线程,你怎样保证T2在T1执行完后执行,T3在T2执行完后执行

public class JoinThreadDemo02 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 20; i++) {
					System.out.println("t1,i:" + i);
				}
			}
		});
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				try {
					t1.join();
				} catch (Exception e) {
					// TODO: handle exception
				}
				for (int i = 0; i < 20; i++) {
					System.out.println("t2,i:" + i);
				}
			}
		});
		Thread t3 = new Thread(new Runnable() {
			public void run() {
				try {
					t2.join();
				} catch (Exception e) {
					// TODO: handle exception
				}
				for (int i = 0; i < 20; i++) {
					System.out.println("t3,i:" + i);
				}
			}
		});
		t1.start();
		t2.start();
		t3.start();
	}
}

面试题

  • 1.进程与线程的区别?
    答:进程是所有线程的集合,每一个线程是进程中的一条执行路径,线程只是一条执行路径。
  • 2.为什么要用多线程?
    答:提高程序效率
  • 3.多线程创建方式?
    答:继承Thread或Runnable 接口。
  • 4.是继承Thread类好还是实现Runnable接口好?
    答:Runnable接口好,因为实现了接口还可以继续继承。继承Thread类不能再继承。
  • 5.你在哪里用到了多线程?
    答:主要能体现到多线程提高程序效率。
    举例:分批发送短信、迅雷多线程下载等。
本文来源GroovRain,由架构君转载发布,观点不代表Java架构师必看的立场,转载请标明来源出处:https://javajgs.com/archives/25367

发表评论