程序、进程、线程的概念
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。
程序是静态的，进程是动态的
线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
若一个程序可同一时间执行多个线程，就是支持多线程的
何时需要多线程
程序需要同时执行两个或多个任务。
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。
需要一些后台运行的程序时。
多线程的创建和启动
Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。
hread类的特性
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
通过该Thread对象的start()方法来调用这个线程
Thread类
构造方法
Thread()：创建新的Thread对象
Thread(Runnable target)：指定创建线程的目标对象，它实现了Runnable接口中的run方法
Thread(Runnable target, String name)：创建新的Thread对象
创建线程的两种方式
创建并启动线程的方法 * 1）实现的方法 * Ⅰ)写一个具体类，实现Runable接口，并实现接口中的抽象方法run，这个run方法就是线程体 * Ⅱ）创建这个具体类对象，并把这个对象作为实参，创建thread线程对象 * Ⅲ）调用Thread线程对象的start方法 * 2）继承的方式 * Ⅰ）写一个类，继承自Thread，并重写run方法，此方法就是线程体 * Ⅱ）创建这个类的对象，相当远创建了线程对象 * Ⅲ）调用这个线程对象的start方法。
package com.day22.thread;
/*
Ⅰ)写一个具体类，实现Runable接口，并实现接口中的抽象方法run，这个run方法就是线程体
Ⅱ）创建这个具体类对象，并把这个对象作为实参，创建thread线程对象
Ⅲ）调用Thread线程对象的start方法
*/
public class HeeloRunner implements Runnable {
private int i;
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"**"+i);
}
}
} public static void main1(String[] args) {
HeeloRunner runner = new HeeloRunner();
Thread thread = new Thread(runner);//对象关联，创建一个新的栈
thread.start();//启动子线程激活栈，并把run方法压入栈底
thread.setName("子线程");
Thread thread1 = new Thread(runner);
thread1.setName("子线程2");
thread1.start();
Thread.currentThread().setName("主线程");
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"$$" + i);
}
}继承方式和实现方式的联系与区别
继承Thread: 线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法
【实现方法的好处】
1）避免了单继承的局限性
2）多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。
Thread类的有关方法
void start(): 启动线程，并执行对象的run()方法
run(): 线程在被调度时执行的操作
String getName(): 返回线程的名称
void setName(String name):设置该线程名称
static currentThread(): 返回当前线程
static void yield()：线程让步
暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程
若队列中没有同优先级的线程，忽略此方法
join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止
低优先级的线程也可以获得执行
static void sleep(long millis)：(指定时间:毫秒)
令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队。
抛出InterruptedException异常
stop(): 强制线程生命期结束
boolean isAlive()：返回boolean，判断线程是否还活着
线程的调度
调度策略
时间片
抢占式：高优先级的线程抢占CPU
Java的调度方法
同优先级线程组成先进先出队列（先到先服务），仍然使用抢占式策略
对高优先级，使用优先调度的抢占式策略
线程的优先级控制
MAX_PRIORITY（10）;
MIN _PRIORITY （1）;
NORM_PRIORITY （5）;
涉及的方法：
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级
线程创建时继承父线程的优先级
使用多线程的优点
多线程程序的优点：
提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
提高计算机系统CPU的利用率
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
线程的生命周期
要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止
线程的分类
Java中的线程分为两类：一种是守护线程，一种是用户线程。
它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收就是一个典型的守护线程。
若JVM中都是守护线程，当前JVM将退出。
//守护线程，setDaemon(ture)；此方法必须在start()以前调用。 //主线程永远是用户线程 //测试方法所在的线程永远是守护线程
Synchronized的使用方法
互斥锁
每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
关键字synchronized 来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
同步的局限性：导致程序的执行效率要降低
同步方法（非静态的）的锁为this。
同步方法（静态的）的锁为当前类本身。
@Override
public /*synchronized*/ void run() {
for (int i = 0; i < 50; i++) {
//锁的粒度要适中
//()中是一个锁对象，任意对象都可以做锁，称为互斥锁，作用是只允许一个线程进入执行，其它进程等待
synchronized ("") {
//具有原子性，不可分割性
counter -= 2;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + counter);
}
}
}锁的释放
当前线程的同步方法、同步代码块执行结束
当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束
当前线程在同步代码块、同步方法中执行了锁对象的wait()方法，当前线程暂停，并释放锁。
不会释放锁的操作
线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行
线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。
应尽量避免使用suspend()和resume()来控制线程
线程的死锁
死锁
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
解决方法
专门的算法、原则
尽量减少同步资源的定义
/**
* 死锁 : 不要嵌套synchronized
* 即使有嵌套, 锁对象尽量少
*/
static StringBuffer s1 = new StringBuffer();
static StringBuffer s2 = new StringBuffer();
public static void main(String[] args) {
new Thread() {
public void run() {
synchronized (s1) { // 可重入锁( 同一个线程可以无限次获取同一个锁)
s2.append("A");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s2.append("B");
System.out.print(s1);
System.out.print(s2);
}
}
}
}.start();
new Thread() {
public void run() {
synchronized (s2) {
s2.append("C");
synchronized (s1) {
s1.append("D");
System.out.print(s2);
System.out.print(s1);
}
}
}
}.start();
}
}
线程通信
wait() 与 notify() 和 notifyAll()
wait()：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问
notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常
wait() 方法
在当前线程中调用方法： 锁对象.wait()
使当前线程进入等待（某对象）状态 ，直到另一线程对该对象发出 notify (或notifyAll) 为止。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
调用此方法后，当前线程将释放对象监控权 ，然后进入等待
在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。
notify()/notifyAll()
在当前线程中调用方法： 对象名.notify()
功能：唤醒等待该对象监控权的一个线程。
调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
package com.day23;
class Counter implements Runnable {
private int n = 1;
@Override
public void run() {
for (int i = 0; i < 50; i++) {
synchronized ("") {
System.out.println(Thread.currentThread().getName() + ":" + n++);
"".notify();
if (i < 49) {
try {
"".wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
public class WaitNotifyTest {
public static void main(String[] args) {
//使用两个线程打印 1-100. 线程1, 线程2 交替打印
Counter counter = new Counter();
Thread thread = new Thread(counter);
thread.setName("线程一");
Thread thread2 = new Thread(counter);
thread2.setName("线程二");
thread.start();
thread2.start();
}
}
扫一扫
1846
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
