进程线程基本问题
一、进程和线程
总结:
进程：
是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多
个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创
建、运行到消亡的过程。
线程：
进程内部的一个独立执行单元；一个进程可以同时并发的运行多个线程，
可以理解为一个进程便相当
于一个单 CPU 操作系统，而线程便是这个系统中运行的多个任务。
二、 多线程程序实现
01: 第一种方式:继承Thread类实现多线程
总结:
1, 继承Thread类
2, 重写run方法
3, 将要执行的代码写在run方法中
4, 创建线程对象
5, 调用start方法开启线程
注意事项:
调用run方法并不是启动线程,跟普通的对象调用方法是一样的
线程要想启动,必须调用 start() 方法,启动线程
线程并不能自己启动, 必须由一个程序来进行启动
案例代码
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
// my1.run();
// my2.run();
//void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法
my1.start();
my2.start();
}
}
public class MyThread extends Thread {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println(i);
}
}
}
三、获取和设置线程名称
总结:
A:获取线程名称的方法:
public String getName() : 获取当前执行线程的名称
是在继承了Thread类中才能使用getName()
如何获取主线程(main)的名称?
Thread.currentThread().getName()
B:设置线程名称的方法
* public Thread(String name) : 创建线程并指定线程的名称
* public void setName(String name) : 设置线程的名称
* Thread(Runnable target, String name) :
案例代码:
public class MyThreadDemo {
public static void main(String[] args) {
// MyThread my1 = new MyThread();
// MyThread my2 = new MyThread();
//
// //void setName(String name)：将此线程的名称更改为等于参数 name
// my1.setName("高铁");
// my2.setName("飞机");
//Thread(String name)
// MyThread my1 = new MyThread("高铁");
// MyThread my2 = new MyThread("飞机");
//
// my1.start();
// my2.start();
//static Thread currentThread() 返回对当前正在执行的线程对象的引用
System.out.println(Thread.currentThread().getName());
}
}
public class MyThread extends Thread {
public MyThread() {}
public MyThread(String name) {
super(name);
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName()+":"+i);
}
}
}
四、设置线程优先级
* final int getPriority() 返回此线程的优先级
* final void setPriority(int newPriority)更改此线程的优先级线程默认优先级是5；
线程优先级的范围是：1-10
* 问题1: 线程默认的级别是?
5
* 问题2: 线程级别的范围是?
1 - 10
线程调度:
* 分时调度
* 抢占式调度(java中默认的方式)
案例代码:
public class ThreadPriorityDemo {
public static void main(String[] args) {
ThreadPriority tp1 = new ThreadPriority();
ThreadPriority tp2 = new ThreadPriority();
ThreadPriority tp3 = new ThreadPriority();
tp1.setName("高铁");
tp2.setName("飞机");
tp3.setName("汽车");
//public final int getPriority()：返回此线程的优先级
// System.out.println(tp1.getPriority()); //5
// System.out.println(tp2.getPriority()); //5
// System.out.println(tp3.getPriority()); //5
//public final void setPriority(int newPriority)：更改此线程的优先级
// tp1.setPriority(10000); //IllegalArgumentException
// System.out.println(Thread.MAX_PRIORITY); //10
// System.out.println(Thread.MIN_PRIORITY); //1
// System.out.println(Thread.NORM_PRIORITY); //5
//设置正确的优先级
tp1.setPriority(5);
tp2.setPriority(10);
tp3.setPriority(1);
tp1.start();
tp2.start();
tp3.start();
}
}
public class ThreadPriority extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(getName() + ":" + i);
}
}
}
线程控制
* static void sleep(long millis)(重点掌握):使当前正在执行的线程停留（暂停执行）指定的毫秒数(在run方法中)
* void join():等待这个线程死亡
* void setDaemon(boolean on):将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出
五、实现Runnable接口
-
实现步骤
* 创建 Runnabel 接口的实现类
* 重写 run方法
* 创建 Runnabel 接口的实现类的对象
* 创建 Thread 对象,将 Runnabel 接口的实现类的对象进行传递
* 使用 Thread 对象 中的 start方法,开启线程使用Runnable接口的好处: * 避免了java中单一继承局限性 * 可以方便的进行资源共享 * 线程Thread 跟 线程要执行的任务run方法有效的分离了,但是要想执行run方法的代码 必须要创建Thread对象,并启动线程
案例代码:
public class MyRunnableDemo {
public static void main(String[] args) {
//创建MyRunnable类的对象
MyRunnable my = new MyRunnable();
//创建Thread类的对象，把MyRunnable对象作为构造方法的参数
//Thread(Runnable target)
// Thread t1 = new Thread(my);
// Thread t2 = new Thread(my);
//Thread(Runnable target, String name)
Thread t1 = new Thread(my,"高铁");
Thread t2 = new Thread(my,"飞机");
//启动线程
t1.start();
t2.start();
}
}
public class MyRunnable implements Runnable {
@Override
public void run() {
for(int i=0; i<100; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
六、线程同步
多线程卖票
* 案例需求:
* 某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
* 实现步骤:
* 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
* 在SellTicket类中重写run()方法实现卖票，代码步骤如下
* 判断票数大于0，就卖票，并告知是哪个窗口卖的
* 卖了票之后，总票数要减1
* 票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
* 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
* 创建SellTicket类的对象
* 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
* 启动线程
案例代码:
public class SellTicketDemo {
public static void main(String[] args) {
//创建SellTicket类的对象
SellTicket st = new SellTicket();
//创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
Thread t1 = new Thread(st,"窗口1");
Thread t2 = new Thread(st,"窗口2");
Thread t3 = new Thread(st,"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();
}
}
//定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
public class SellTicket implements Runnable {
private int tickets = 100;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
@Override
public void run() {
// A:判断票数大于0，就卖票，并告知是哪个窗口卖的
// B:卖了票之后，总票数要减1
// C:票没有了，也可能有人来问，所以这里用死循环让卖票的动作一直执行
while (true) {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
tickets--;
}
}
}
}
1.卖票案例的问题
总结:
* 卖票所出现的问题有那些?
* 卖重复的票
* 有负数的票
* 有0号票
* 问题产生的原因?
* 多线程随机的特点,导致卖票的时候出现了以上三个问题
- 解决线程安全问题
* 同步机制的介绍
* 1.什么情况下需要同步
* 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.
* 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.
* 2.同步技术分类
* 同步代码块
* 同步方法
* Lock锁
- 使用同步代码块解决数据安全问题
总结:
* 同步技术的原理
使用 synchronized 同步块将共享数据进行锁起来,多个线程在执行的时候,会抢夺CPU的执行权
当某一个线程抢到执行权时,会先判断这个锁是否存在,如果存在就获取锁,这个线程就带着这个锁执行
同步代码块中的代码,直到执行完成之后,才释放锁. 没有锁的线程执行在通过代码块外等.
public class SellTicket implements Runnable {
private int tickets = 100;
//在SellTicket类中重写run()方法实现卖票，代码步骤如下
Object obj = new Object();
@Override
public void run() {
while (true) {
synchronized (obj) {
if (tickets > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "正在出售第" + (tickets--) + "张票");
// tickets--;
}
}
}
}
}
七、使用同步方法解决线程安全问题.
* 非静态同步方法
总结:
* 同步方法:
把多个线程操作共享数据的代码,放到一个方法中
* 格式:
修饰符 synchronized 返回值类型 方法名(参数列表){}
* 注意：
非静态同步方法的锁对象是谁?
this
* 静态同步方法
* 格式:
修饰符 static synchronized 返回值类型 方法名(参数列表){}
* 注意：
* 静态同步方法的锁对象是谁?
Class锁
当前类名.class
选择一个锁的对象的时候,优先选择当前类的字节码对象这个锁
- 线程同步安全的类
总结:
- 使用Lock锁解决线程安全问题
* Lock概述 :
Lock锁中通过lock和unlock两个方法, 可以解决线程的安全问题, 因为是调用方法解决, 所以体现的更为面向对象
* 方法摘要
public void lock() : 加同步锁。
public void unlock() :释放同步锁
补充: Lock锁是jdk1.5版本之后出现的.
* 案例代码:
##04: 生产者和消费者
- 等待唤醒机制概述
* 铺垫 : 实现线程间的通讯, 使用的就是等待唤醒机制
* 问题 : 等待唤醒机制使用的是哪两个方法
总结:
* 等待唤醒机制使用的是哪两个方法
1. 等待 -> wait : 让当前线程在此进入无限等待状态, 需要另一条线程对其进行唤醒.
2. 唤醒 -> notify : 随机唤醒单个线程.
notifyAll() : 唤醒所有等待的线程
- 等待唤醒机制需求分析(生产者和消费者)
- 安全步骤:
- 生产者消费者案例中包含的类：
- 奶箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
- 生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作
- 消费者类(Customer)：实现Runna ble接口，重写run()方法，调用获取牛奶的操作
- 测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下
①创建奶箱对象，这是共享数据区域
②创建消费者创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
③对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
⑤启动线程
- 生产者消费者案例中包含的类：