是为了完成某个特定的任务,用某种语言编写的一组指令的集合。
简单来说:就是我们写的代码
程序进程线程: 进程:(1)是指运行中的程序
比如说我们启动了一个英雄联盟,操作系统会自动为该进程分配一个内存空间,再启动一个穿越火线,操作系统又会为该进程分配一个新的内存空间。
(2)进程是程序的一次执行过程,或者是正在运行中的一个程序。是动态过程:它自身有产生、存在、消亡的过程。
线程:1.是由进程创建的,是进程的一个实体
2.一个进程可以有多个线程
3.线程也可以创建线程
4.单线程:
同一时刻之允许执行一个线程
5.多线程:
同一时刻可以运行多个线程。 如:在qq这个进程里面打开多个聊天窗口......
并发并行:并发:
同一时刻多个任务交替执行。 因为cup的切换任务速度快,所以给人的一种“貌似同时”错觉,单核心cpu实现的多任务就是并发。
并行:
同一时刻,多个任务同时执行,多核cup可以实现并行。
当进程过多,cup处理不过来,也会出现并发和并行同时存在。
如何查看当前电脑可并行进程数量:查看方法有很多种
这里用代码来查看展示:
public class SelectCpuMuch {
public static void main(String[] args) {
Runtime runtime = Runtime.getRuntime();
//获取当前电脑cpu线程数量
int num = runtime.availableProcessors();
System.out.println("cup可同时运行进程数量:"+num);
}
}
示例:
如何创建线程 在Java中有两种方式创建线程:1.继承Thread类,重写run()方法
2.实现Runnable接口,重写run()方法
类图:
案例一:
编写一个程序,开启一个线程,该线程每隔一秒在控制台输出“我是猪猪侠”,当输出10条时结束程序。
先编写一个Test类继承Thread这个类:
class Test extends Thread {
int num = 0;
@Override
//重写run()方法
public void run() {
while (true) {
System.out.println("我是猪猪侠" + (++num));
try {
Thread.sleep(1000); //线程休眠一秒,即停止一秒再接着运行
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num == 10) {
break;
}
}
}
}
示例:
执行过程:当程序启动时就会创建一个main线程,然后继续创建子线程,并且main线程不会被堵塞,main线程在执行,子线程也在执行,当main线程执行完成,子线程还可以继续执行,并不会因为main线程的完成而结束整个进程。子线程也可以创建线程。
main线程得实现线程接口
public static void main(String[] args) throws InterruptedException {}
代码:
public class Thread_01 {
public static void main(String[] args) throws InterruptedException {
Test c = new Test();
c.start();
System.out.println("主线程继续运行");
for(int i = 0;i < 5;i++){
System.out.println("主线程 i="+i);
Thread.sleep(1000);
}
}
}
class Test extends Thread {
int num = 0;
@Override
public void run() {
while (true) {
System.out.println("我是猪猪侠" + (++num));
try {
Thread.sleep(1000); //线程休眠一秒,即停止一秒再接着运行
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num == 10) {
break;
}
}
}
}
示例:
如果想要看到线程名可以用这个方法
如何监视线程:Thread.currentThread().getName()
1.在终端输入这个指令
jconsole
进入这个界面,选择本地连接,选择这个类
为什么不是调用run()方法,而是调用start()方法1.因为run()方法只是一个普通的方法,如果调用的run()方法,程序会把run()方法先执行完,而此时执行这个线程的是main线程,这个可以通过查看线程名可以看的到,只有一个线程在执行,只有把run()方法执行完了才会执行main方法(),会阻塞在main()方法,没有真正启动线程,所以并不是多线程了。
2.代码示例
public class Thread_01 {
public static void main(String[] args) throws InterruptedException {
Test c = new Test();
c.start();
System.out.println("主线程继续运行");
for(int i = 0;i < 5;i++){
System.out.println("主线程 i="+i);
Thread.sleep(1000);
}
}
}
class Test extends Thread {
int num = 0;
@Override
public void run() {
while (true) {
System.out.println("我是猪猪侠" (++num)+Thread.currentThread().getName());
try {
Thread.sleep(1000); //线程休眠一秒,即停止一秒再接着运行
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num == 200) {
break;
}
}
}
}
示例:
流程图:
使用Runnable接口实现多线程:1.因为java继承机制是单继承,如果一个A类继承了一个B类再去继承Thread这个类显然是不行的所以java设计者提供了另一个方式实现多线程,那就是实现Runnable接口来实现多线程。
2.示例代码
public class Thread_02 {
public static void main(String[] args) {
Test02 test02 = new Test02();
Thread thread = new Thread(test02);
thread.start();
}
}
class Test02 implements Runnable{
int num = 0;
@Override
public void run() {
while (true) {
System.out.println("我是猪猪侠(++num)+Thread.currentThread().getName());
try {
Thread.sleep(1000); //线程休眠一秒,即停止一秒再接着运行
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num == 5) {
break;
}
}
}
}
3.注意事项:
(1).Runnable接口是没有start()方法的,只有run()方法,但是上面说到,run()只是一个普通方法,不能真正实现多线程。
(2).创建一个Thread,把这个test02放进去,就可以使用sratr()方法了
4.示例
线程终止:只需要将进入循环条件设置为私有,然后在主线程里设置成false,就有终止线程
代码示例:
public class Thread_04 {
public static void main(String[] args) throws InterruptedException {
Test test = new Test();
test.start();
Thread.sleep(5000); //让主线程休眠5秒再启动,这时就会终止子线程
test.setBool(false);
}
}
class Test extends Thread{
private boolean bool = true;
@Override
public void run() {
while (bool) {
System.out.println(Thread.currentThread().getName() + "线程运行中");
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void setBool(boolean bool) {
this.bool = bool;
}
}
示例:
线程提前终止休眠线程提前终止休眠可以用interrupt()这个方法
代码示例:
public class Thread_05 {
public static void main(String[] args) {
Test_01 test_01 = new Test_01();
test_01.setName("猪猪侠");
test_01.start();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("猪猪侠不想休眠了,继续吃");
test_01.interrupt();//提前终止休眠,让线程继续执行
}
}
class Test_01 extends Thread{
private boolean bool = true;
@Override
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() + "吃包子" );
try {
System.out.println(Thread.currentThread().getName() + "休眠中");
Thread.sleep(10000);
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + "提前中断休眠");
}
}
}
}
示例:
线程设置优先级:设置线程优先级为最低(等级1):
setPriority(Thread.MIN_PRIORITY)
设置线程优先级为最高(等级10):
setPriority(Thread.MAX_PRIORITY)
设置线程优先级为普通(等级5):
setPriority(Thread.NORM_PRIORITY
示例:
用getPriority()这个方法可以获取到优先级
线程插队:join()方法实现线程插队
线程插队一旦成功,肯定先执行完成插队线程的所有任务。
1.当不使用线程插队示例代码:
public class Thread_06 {
public static void main(String[] args) throws InterruptedException {
Test_03 test_03 = new Test_03();
test_03.start();
for(int i = 0;i < 10;i++){
System.out.println("GG-bone");
}
}
}
class Test_03 extends Thread{
int num = 0;
@Override
public void run() {
while (true) {
System.out.println("猪猪侠吃棒棒糖"+(++num));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(num == 5){
break;
}
}
}
}
结果:
可以看到先执行主线程,再执行子线程
2.当使用线程插队时
代码示例:
public class Thread_06 {
public static void main(String[] args) throws InterruptedException {
Test_03 test_03 = new Test_03();
test_03.start();
test_03.join(); //线程插队
for(int i = 0;i < 10;i++){
System.out.println("GG-bone");
}
}
}
class Test_03 extends Thread{
int num = 0;
@Override
public void run() {
while (true) {
System.out.println("猪猪侠吃棒棒糖"+(++num));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(num == 5){
break;
}
}
}
}
结果:
使用线程插队后,先执行完成插队线程再回去执行主线程



