Java Thread

发表于 | 更新于 | 评论数： | 阅读次数：

写在开头

 线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
 一个进程可以有很多线程，每条线程并行执行不同的任务。
 今天我们说一下Java编程的很重要的一部分:线程.

线程

程序

  • 程序是是一组指令的有序集合,是具有一定的逻辑和数据的处理能力的代码的集合

进程

  • 进行是在内存中运行的程序,是具有一定独立功能的程序关于某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个独立单位

线程

  • 线程是进进程的一个实体,是CPU调度和分派的基本单位.进程中的一个执行通道,叫做线程.进程中如果有多个执行通道,那么就称为多线程,线程通道之间彼此是独立的,互不干扰的

 定义啥的每个人解释的都不尽相同,打开计算机的资源管理器,里面就显示着当前正在运行的程序
 再逼逼叨几句,以便更好的理解三者

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
一个程序至少有一个进程,一个进程至少有一个线程.

线程的划分尺度小于进程，使得多线程程序的并发性高。

另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。
但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.

线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行.

并行和并发

并行性和并发性是既相似又有区别的两个概念。

并行性是指两个或多个事件在同一时刻发生。

而并发性是指连个或多个事件在同一时间间隔内发生。在多道程序环境下，并发性是指在一段时间内宏观上有多个程序在同时运行，但在单处理机环境下（一个处理器），每一时刻却仅能有一道程序执行，故微观上这些程序只能是分时地交替执行。例如，在1秒钟时间内，0-15ms程序A运行；15-30ms程序B运行；30-45ms程序C运行；45-60ms程序D运行，因此可以说，在1秒钟时间间隔内，宏观上有四道程序在同时运行，但微观上，程序A、B、C、D是分时地交替执行的。

多线程的实现方式

继承Thread类

  • Thread: 类,就是表示一个线程,表示程序中一条执行通路,Java虚拟机允许应用程序同时执行多个线程

直接上代码,使用方法在代码中以注释的形式诠释

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package io.cnfox.thread;

// 1.自定义一个类,继承Thread类(自定义类就是一个线程类)
public class SubThread extends Thread {
	
	// 2.自定有类中重写Thread类中的方法,public void run(){}, run方法中写入要通过线程单独执行的代码
	@Override
	public void run() {
		
		for(int i = 0 ; i < 10 ; i++) {
			System.out.println("run---"+i);
			
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package io.cnfox.thread;

public class TestThread {

	// in thread "main" main本身就是一个线程,名字就叫做main
	public static void main(String[] args) {
		
		// 3.创建自定义的线程类对象
		SubThread st = new SubThread();
		
		// 4. 调用方法,开启线程
		// st线程调用了start方法,开启了st所代表的线程,Java虚拟机,调用st线程中的run方法
		// 线程的执行,具有随机性
		st.start();
		// run() : 并不是开启线程的方法,只是一个普通方法
		//st.run();
		
		for( int i = 0 ; i < 10 ; i ++) {
			
			System.out.println("main---"+i);
		}
	}
}

运行结果具有随机性,但是由于线程循环次数较少没有体现出来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
main---0
main---1
main---2
main---3
main---4
main---5
main---6
main---7
main---8
main---9
run---0
run---1
run---2
run---3
run---4
run---5
run---6
run---7
run---8
run---9

实现Runnable接口

  • Runnable : 接口,用于实现一个线程

直接上代码,使用方法在代码中以注释的形式诠释

1
2
3
4
5
6
7
8
9
10
11
12
13
package io.cnfox.thread;
// 1.自定义一个类,实现Runnable接口
public class SubRunnable implements Runnable {

	//2.重写Runnable中的抽象方法run()
	@Override
	public void run() {
		for(int i  = 0 ; i < 10 ; i ++) {
			
			System.out.println("runnable-----"+i);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package io.cnfox.thread;

public class TestRunnable {

	public static void main(String[] args) {
		// 3. 将自定义的类,作为构造参数传递到Thread中 
	   SubRunnable sr = new SubRunnable();
       Thread t = new Thread(sr);
       
       // 4.开启一个线程, Thread中的start() 方法
       t.start();
       
       for(int i = 0 ; i < 10 ; i++) {  
    	  System.out.println("main+++" + i); 
       }
	}
}

运行结果具有随机性,但是由于线程循环次数较少没有体现出来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

main+++0
main+++1
main+++2
main+++3
main+++4
main+++5
main+++6
main+++7
main+++8
main+++9
runnable----0
runnable----1
runnable----2
runnable----3
runnable----4
runnable----5
runnable----6
runnable----7
runnable----8
runnable----9

Thread类和Runnable实现线程的区别

  1. 实现方式不同,Thread需要继承,Runnable需要实现

  2. 内部方法调用不同
    Thread 类.调用start方法,JVM默认调用当前执行线程的run方法(重写),JVM默认调用这处,看不到代码
    Runnable 接口: 将实现类作为参数传递进Thread的构造方法中,通过一些列的init方法,最终将实现类给Runnable类型的成员进行赋值, 调用run方法,判断,如果传递的实现类为null,什么都不错;如果传递的不是null,那么就调用这个实现累的run方法在线程中运行

  3. 使用
    Thread ,使用起来简单,但是类之间的耦合性增加了,原因: 一个类只能有一个直接父类
    Runnable,使用比较复杂,但是类与类之间的耦合性屏蔽掉,接口是可以多实现的

    总结: 多数情况下,更加倾向于使用Runnable接口.

匿名Thread类&匿名Runnable接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package io.cnfox.thread;

public class Niming2 {

	public static void main(String[] args) {

		// 这是匿名内部类的第二次练习
		// Thread new 的时候 Thread的 T 一定是大写
		// 要有重写的标志 @Override
		new Thread() {
			@Override
			public void run() {

				for (int i = 0; i < 50; i++) {
					System.out.println(getName() + "$$$" + i);
				}
			}
		}.start();
		
		// 给线程设置名称
		/*Thread t = new Thread() {
			@Override
			public void run() {

				for (int i = 0; i < 50; i++) {
					System.out.println(getName() + "&&&" + i);
				}
			}
		};
		
		t.setName("设置线程名称");
		t.start();*/
		
//runnable 没有大括号!!!
		new Thread(
				new Runnable() {
					@Override
					public void run() {
						for (int i = 0; i < 50; i++) {
							System.out.println("$$$" + i);
						}
					}
				}).start();

	}

}

线程名称的相关内容

  1. getName() :获取当前线程的名字,返回值类型String类型
    线程的命名规则:Thread-x x就表示数字,数字从0开始,一直往后,每次x+1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package io.cnfox.thread;
public class ThreadDemo1 {

	public static void main(String[] args) {
		// 匿名内部类就是Thread的子类
		new Thread() {
			
		@Override
		public void run() {
			for(int i = 0 ; i < 5 ; i++) {
				// getName() 直接使用了从父类继承来的方法
				System.out.println(getName()+"----"+i);
			}
			
		   }	
		}.start();
		
		
		// 匿名内部类就是Thread的子类
		new Thread() {
					
				@Override
				public void run() {
					for(int i = 0 ; i < 5 ; i++) {
						// getName() 直接使用了从父类继承来的方法
						System.out.println(getName()+"----"+i);
					}
					
				   }
				}.start();
	       }
      }
  1. setName(String name): 给线程设置名字
  2. Thread的构造方法,也可以写线程设置名字
    举例: Thread(Runnable target, String name)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package io.cnfox.thread;
public class ThreadDemo1 {
//setName(String name): 给线程设置名字
	public static void main(String[] args) {
		// 匿名内部类就是Thread的子类
		Thread t1 = new Thread() {
					
				@Override
				public void run() {
					for(int i = 0 ; i < 5 ; i++) {
						//getName() 直接使用了从父类继承来的方法
						System.out.println(getName()+"----"+i);
					  }
					
				   }
					
				};
				// setName(String name) : 给线程设置名字,name
				t1.setName("线程设置名字");
				t1.start();
	       }
      }
1
2
3
4
5
6
7
8
9
10
package io.cnfox.thread;
public class ThreadName implements Runnable{

	@Override
	public void run() {
		for(int i = 0 ; i < 5; i ++) {
			System.out.println(i);
		}	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package io.cnfox.thread;
public class TestThreadName {

	public static void main(String[] args) {
// 构造方法给线程设置名字
		Thread t = new Thread(new ThreadName(),"小强");
		System.out.println(t.getName());
		
		
		Thread t1 = new Thread(new ThreadName(),"小guo");
		System.out.println(t1.getName());

	}
}

获取正在运行的线程对象

程序—方法—逻辑, 逻辑如果要执行的话,必须要写在方法内部,如果方法可以执行的话,程序中一定是有线程(通路)来执行这个方法,证明有线程正在运行,因此可以获取到正在运行的线程的对象

Thread 类中,有一个static cuttentThread() 方法,返回值类型是Thread类的一个对象
举例:
Thread.currentThread().getName()

1
2
3
4
5
6
7
8
9
10
11
12
package io.cnfox.thread;

public class ThreadName implements Runnable{

	@Override
	public void run() {
		for(int i = 0 ; i < 5; i ++) {
			//Thread.currentThread() : 返回值类型是Thread类的一个对象
			System.out.println(Thread.currentThread().getName() + i);
		}	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package io.cnfox.thread;

public class TestThreadName {

	public static void main(String[] args) {
		// Thread.currentThread() 就表示当前正在运行的线程: main
		System.out.println(Thread.currentThread().getName());
		
		Thread t = new Thread(new ThreadName(),"小强");
		t.start();
		//System.out.println(t.getName());
		
		Thread t1 = new Thread(new ThreadName(),"小倩");
		t1.start();
		//System.out.println(t1.getName());
	}
}

运行结果具有随机性,但是由于线程循环次数较少没有体现出来

1
2
3
4
5
6
7
8
9
10
小倩0
小倩1
小倩2
小倩3
小倩4
小强0
小强1
小强2
小强3
小强4

线程的休眠

sleep() 的作用是让当前线程休眠，即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间，线程休眠的时间会大于/等于该休眠时间；在线程重新被唤醒时，它会由“阻塞状态”变成“就绪状态”，从而等待cpu的调度执行。

使用方法:
sleep(long millis) 线程睡眠 millis 毫秒
sleep(long millis, int nanos) 线程睡眠 millis 毫秒 + nanos 纳秒

如何调用:
因为sleep()是静态方法，所以最好的调用方法就是 Thread.sleep()。

调用位置:
线程的sleep方法应该写在线程的run()方法里，就能让对应的线程睡眠。

sleep 方法会抛出异常,java.lang.InterruptedException
正在进行等待或者休眠的线程,被打断了,线程终止了,抛出上述异常
run方法来自于父类或者父接口,父类针对于run没有抛出任何异常,子类重写run时,也不能抛出异常,可以在run方法内部处理异常(try…catch)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package io.cnfox.thread;
public class ThreadName implements Runnable{

	@Override
	public void run() {
		for(int i = 0 ; i < 5; i ++) {
			//static sleep(long 毫秒值): 表示线程休息一定的时间(毫秒值时间),到时间之后,程序醒来,继续争夺CPU的资源运行
			// sleep 方法会抛出异常,java.lang.InterruptedException 
			// 正在进行等待或者休眠的线程,被打断了,线程终止了,抛出上述异常
			// run方法来自于父类或者父接口,父类针对于run没有抛出任何异常,
			// 子类重写run时,也不能抛出异常,可以在run方法内部处理异常(try...catch)
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//Thread.currentThread() : 返回值类型是Thread类的一个对象
			System.out.println(Thread.currentThread().getName() + i);
		}	
	}
}

守护线程

⁧守护线程就像是一个配角,如果非守护线程都没有结果,守护线程就可以正常运行,如果非守护线程都已经结束,守护线程就结束执行.
⁧这样说可能有点抽象,举一个栗子:pc版本的qq,聊天的对话框和QQ主界面这两个线程同时,你关闭了聊天的对话框,QQ主界面不会被关闭,但是如果你关闭了QQ主界面,聊天的对话框就会被程序关闭.
⁧在这个栗子里,聊天的对话框就是一个守护线程,而QQ主界面就是一个非守护线程~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package io.cnfox.thread;
public class ShouHuThread {

	public static void main(String[] args) {
		// 非守护线程
		Thread t1 = new Thread() {
			
			@Override
			public void run() {
				 for(int i = 0 ; i < 2 ; i ++) {
					System.out.println("A------"+i); 
				 }
			}
		};
		
		t1.start();
		
		// 守护线程
        Thread t2 = new Thread() {
			
			@Override
			public void run() {
				 for(int i = 0 ; i < 50 ; i ++) {
					System.out.println("B------"+i); 
				 }
			}
		};
		// setDaemon(true):将此线程标记为守护线程
		// 说明: 非守护线程,执行完毕,在没有非守护线程,t2这个守护线程也要结束,结束有个过程,所以现象是,并不是立马结束
		t2.setDaemon(true);
		t2.start();
	}
}

线程的优先级

线程的优先级: 作用,优先级高的线程先执行,多执行,会多占用CPU的资源,但是多线程的运行,就算线程之间具有优先级,结果仍然具有随机性

方法setPriority(int newPriority) : 更改线程的优先级,参数int值越大,线程的优先级就越高

Thread类中的静态变量,标识线程的优先级,变量都是int类型

MAX_PRIORITY 最大线程优先级别 ———- 10
MIN_PRIORITY 最小的线程优先级别——— 1
NORM_PRIORITY 默认的线程优先级别——— 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package io.cnfox.thread;
public class ShouHuThread {

	public static void main(String[] args) {
		// 非守护线程
		Thread t1 = new Thread() {
			
			@Override
			public void run() {
				 for(int i = 0 ; i < 50 ; i ++) {
					System.out.println("A------"+i); 
				 }
				
			}
			
		};
		// 给线程t1设置最大的线程优先级别
		t1.setPriority(Thread.MAX_PRIORITY);
		t1.start();
		
		// 守护线程
     Thread t2 = new Thread() {
			
			@Override
			public void run() {
				 for(int i = 0 ; i < 50 ; i ++) {
					System.out.println("B------"+i); 
				 }
				
			}
			
		};
		// setDaemon(true):将此线程标记为
		// 说明: 非守护线程,执行完毕,再也没有非守护线程执行,t2这个守护线程也要结束,结束有个过程,所以现象是,并不是立马结束
		//t2.setDaemon(true);
		// 给线程t2设置最小的线程优先级别
		t2.setPriority(Thread.MIN_PRIORITY);
		t2.start();
	}

}

线程安全

线程安全: 多个线程同时在操作同一部分数据,有可能或发生线程安全问题

电影院卖票线程安全问题案例

要求: 电影院 <千与千寻> ,这一场卖100张票,座位号1-100
卖票要求: 线上线下同步销售, 从四个渠道 美团网,猫眼,影院,淘宝 都可以销售影票

同步代码块解决线程安全

同步代码块,格式:
synchronized(对象锁){
// 可能会发生线程安全的代码

}

synchronized : 同步,将线程的处理逻辑,放置到同步代码块中,就能解决线程的安全问题
(对象锁) : 就是一个对象,要求,如果多个线程同时执行同步代码块中的内容,对象锁必须是同一个对象
{}: 大括号中,写上可能会发生线程安全的代码

总结:

  1. 线程进同步代码块执行程序,先判断同步的对象锁是否存在
    存在,将对象锁获取到,取走,进入同步代码块中执行
    不存在,不能进入同步代码块进行代码的执行,只能在同步外等待
  2. 线程执行完同步代码块中的内容,出同步,将锁对象归还给同步代码块
  3. 有了锁对象,其他资源都可以竞争,进入同步执行,进同步又拿走同步锁,以此类推
  4. 一定要保证,多个线程使用对象锁是唯一的,如果同步锁不唯一,仍然无法保持线程的安全

以下代码已实现同步代码块解决线程安全

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package io.cnfox.thread;

/*
 * 要求: 电影院 <千与千寻> ,这一场卖100张票,座位号1-100
   卖票要求: 线上线下同步销售, 从四个渠道 美团网,猫眼,影院,某宝 都可以销售影票
 * 
 * */
public class Tickets implements Runnable {
	
	private static int ticket = 100;
	Object obj = new Object();

	@Override
	public void run() {// 四个独立的线程,都可以进行票的销售,卖票过程,写在run线程中
		// 如果ticket <= 0 不能继续销售了,票卖完了
	while(true) {
	  synchronized(obj) {// 同步代码块,解决线程安全问题,小括号中的对象,可以是任意对象,但是要保证对象时唯一的(针对多线程)
		// 卖票
		 //  while(ticket > 0) {
		  if( ticket > 0) {
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"销售第"+(ticket--)+"张票");
		    }	
	     }	
	    }
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package io.cnfox.thread;
/*
 * 
 *   定义4个销售渠道,卖票
 *   4个线程,操作同一部分数据  100张票
 * */
public class SaleTickets {

	public static void main(String[] args) {
		
		Tickets t = new Tickets();
		// 定义美团渠道
		Thread t1 = new Thread(t ,"美团网");
		// 定义美团渠道
		Thread t2 = new Thread(t ,"猫眼");
		// 定义美团渠道
		Thread t3 = new Thread(t ,"影院");
		// 定义美团渠道
		Thread t4 = new Thread(t ,"淘宝");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

晚安

 今天就到这里了，明天见，加油！

-------------本文结束感谢您的阅读-------------
0%