1.进程概念
正在执行的程序,每一个进程执行都有一个执行顺序,该执行顺序是一个执行路径(执行情景),或者叫一个控制单元
2.线程概念
就是进程中一个独立的控制单元,线程在控制着进程的执行
一个进程中至少有一个线程
参考迅雷下载过程理解
3.Java虚拟机启动时会有一个进程java.exe,该进程中至少有一个线程负责Java程序的执行,而且这个线程的运行代码存在于main方法中,该线程称为主线程
扩展知识:其实更细节说明Java虚拟机JVM,JVM启动不止一个线程,还有负责垃圾回收机制的线程
4.如何在自定义的代码中自定义一个线程呢?
(1)方式一
步骤:1,定义类继承Thread
2,复写Thread类中的run方法
3,调用线程的start方法,该方法有两个作用,启动线
程和调用run方法
实例:
class Demo extends Thread
{
public void run()
{
for (int i = 0; i < 60 ; i++)
{
System.out.println("Demo" + i);
}
}
}
public class ThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo(); //创建一个线程
//开启线程,并执行该线程中的run方法
d.start();
//仅仅是对象调用方法,而线程创建了却没有运行。
//d.run();
for (int i = 0; i < 60 ; i++)
{
System.out.println("Hello World!" + i);
}
}
}
5.多线程的特性
多线程都在获取CPU的执行权,CPU执行到谁,谁就运行。明确一点,在某一个时刻,只能有一个程序(线程)在运行(多核除外)。CPU在做着快速的切换以达到看上去是在同时运行的效果。我们可以形象地把多线程的运行形容为在互相争夺CPU的执行权,这就是多线程一个特性:随机性。谁抢到谁执行,至于执行多长时间,CPU说了算。
6.为什么要覆盖run方法
Thread用来描述线程。该类就定义了一个功能,用来存储线程要运行的代码,该功能就是run方法,换句话说,Thread类中的run方法用来存储线程要运行的代码。对应于主线程要运行的代码存储在main函数中
7.线程的状态
(1)被创建:new一个Thread类及其子类对象,调用底层
(2)运行状态:既有运行资格,又有执行权
(3)阻塞状态:具有运行资格,但没有执行权
(4)冻结状态:既没有运行资格,也没有执行权
运行状态到冻结状态有两种方式,一是调用sleep(time)睡眠方法,二是调用wait()等待方法
当冻结状态睡眠时间到或者被唤醒时,线程从冻结状态过渡到阻塞(临时)状态,先获取运行资格,再变成运行状态
8.获取线程对象的方法
线程都有自己默认的名称:Thread-编号,编号从0开始
Thread.currentThread().getName()
9.线程中的几个小函数
currentThread(); //获取当前线程对象
getName(); //获取线程名称
注意
(1)设置线程名称:setName或者通过super语句调用父类构造函数
(2)局部变量在每一个线程区域中都有独立的一份
9.创建线程的第二种方式:实现Runnable接口
步骤:
(1)定义类实现Runnable接口
(2)覆盖Runnable接口中的run方法
将线程将要运行的代码存放在该run方法中
(3)通过Thread类建立线程对象
(4)将Runnable接口中的子类对象作为实际参数传递给Thread
类的构造函数
因为自定义的run方法中所属对象是Runnable接口的子类对
象,所以要让线程去指定对象的run方法。就必须明确该
run方法所属对象
(5)调用Thread类的start方法开启线程并调用Runnable接口子
类的run方法
10.实现方式的好处
(1)避免了单继承的局限性
(2)在定义线程时,建议使用实现方式
11.继承和实现两种方式的区别
继承Thread:线程代码存在在Thread子类run方法中
实现Runnable:线程代码存放在接口子类的run方法中
12.多线程的安全问题
问题原因:当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,另一个线程参与进来执行,导致共享数据的错误。
解决办法:对多条操作共享数据的语句,只能让某一个线程都执行完。在执行过程中,其它线程不可以参与执行。
Java对于多线程的安全问题,提供了专业的解决办法,就是同步代码块
synchronized(对象)
{
需要被同步的代码;
}
哪些代码需要被同步?就看哪些代码在操作共享数据
实例:
class Ticket implements Runnable
{
private int tick = 100; //售票总数为100
Object obj = new Object();
public void run()
{
while(true)
{
synchronized(obj)
{
if(tick > 0)
{
try{Thread.sleep(10);} catch (Exception e) {}
System.out.println(Thread.currentThread().getName() + "sale
ticket" + tick--);
}
}
}
}
}
public class ThreadDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
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();
}
}
同步代码块
synchronized(对象)
{
需要被同步的代码;
}
对象如同锁,持有锁的线程可以在同步中执行,没有持有锁的线程即使获取CPU的执行权,也进不去,因为没有锁。
火车上的卫生间
同步的前提:
(1)必须有两个或两个以上的线程
(2)必须是多个线程使用同一个锁
必须保证同步中只能有一个线程在运行
同步函数:将synchronized关键字放在函数上修饰即可
同步函数使用的是哪一个锁?
函数需要被对象调用。那么函数都有一个所属对象引用,就是this。同步函数使用的锁就是this。
如果同步函数被静态static修饰后,使用的锁是什么?
静态方法中不可以定义this。静态方法进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象:类名.class。该对象的类型是Class。静态的同步方法使用的锁就是该方法所在类的字节码文件对象,即类名.class。
13.线程死锁:同步中嵌套同步
class Test implements Runnableja
{
private boolean flag;
Test(boolean flag)
{
this.flag = flag;
}
public void run() //存放线程运行的代码
{
if(flag)
{
synchronized(MyLock.locka)
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.out.println("if lockb");
}
}
}
else
{
synchronized(MyLock.lockb)
{
System.out.println("else lockb");
synchronized(MyLock.locka)
{
System.out.println("else locka");
}
}
}
}
}
class MyLock
{
static Object locka = new Object();
static Object lockb = new Object();
}
public class DeadLockDemo
{
public static void main(String[] args)
{
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}
注意:当同步之后还出现问题时,先考虑是否满足了同步的前提