程序,进程,线程
程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码。
进程((process) 就是正在执行的程序,从Windows角度讲，进程是操作系统进行 资源分配的最小单位.
线程(thread) 进程可进一步细化为线程，是一个进程内部的最小执行单元，是操 作系统进行任务调度的最小单元，隶属于进程
线程和进程的关系
线程和进程的关系:
- 一个进程可以包含多个线程，一个线程只能属于一个进程，线程不能脱离进程 而独立运行；
- 每一个进程至少包含一个线程(称为主线程)；在主线程中开始执行程序， java 程序的入口main()方法就是在主线程中被执行的。
- 在主线程中可以创建并启动其它的线程；
- 一个进程内的所有线程共享该进程的内存资源
创建线程
继承Thread类的方式
实现Runnable接口的方式
public class Demo1 implements Runnable {
@Override
public void run(){
for (int i = 0; i < 1000; i++) {
System.out.println("Demo1"+i);
}
}
/**
* 重写的Run方法
*/
}
public class Demo2 {
public static void main(String[] args) {
//创建线程对象
Demo1 d1 = new Demo1();
//创建线程，并对线程指定任务
Thread thread = new Thread(d1);
thread.start();
//主线程
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i);
}
}
}
继承方式和实现方式的联系与区别
区别:
- 继承Thread: 线程代码存放Thread子类run方法中。
- 实现Runnable：线程代码存在接口的子类的run方法。
实现Runnable的好处:
- 避免了单继承的局限性
- 多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处 理同一份资源。
Thread类中方法
构造方法：
常用的基本方法：
public class Demo2 {
public static void main(String[] args) {
Demo1 d1 = new Demo1();
Thread thread = new Thread(d1,"t1");//给其命名
thread.start();
thread.setPriority(5);//设置优先级，1-10
}
}
线程优先级
事实上，计算机只有一个CPU，各个线程轮流获得CPU的使用权，才能 执行任务；优先级较高的线程有更多获得CPU的机会，反之亦然。优先级用整数表示，取值范围是1~10，一般情况下，线程的默认优先级都是5，但是也可以通过setPriority和getPriority方法来设置或返回优先级
调度策略：
- 时间片
- 抢占式：高优先级的线程抢占CPU
Java的调度方法
- 同优先级线程组成先进先出队列，使用时间片策略
- 对高优先级，使用优先调度的抢占式策略
线程状态
线程在它的生命周期中会处于不同的状态
线程的分类
Java中的线程分为两类：用户线程和守护线程
- 用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：
- 只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；
- 只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。
- 守护线程的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。
- 用户线程和守护线程两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 用户线程已经全部退出运行了，只剩下守护线程存在了，虚拟机也就退出了。 因为没 有了被守护者，守护线程也就没有工作可做了，也就没有继续运行程序的必要了
- 注意:设置线程为守护线程必须在启动线程之前，否则会跑出一个
多线程的概念
多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多 个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行 执行的线程来完成各自的任务。
何时需要多线程?
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、 网络操作、搜索等
- 需要一些后台运行的程序时
多线程的优点:
- 提高程序的响应
- 提高CPU的利用率
- 改善程序结构,将复杂任务分为对个线程,独立运行.
多线程的缺点:
- 线程也是程序，所以线程需要占用内存，线程越多占用内存也越多；
- 多线程需要协调和管理，所以需要CPU时间跟踪线程；
- 线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题；
线程同步
并发与并行
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU（采用时间片）同时执行多个任务。比如：秒杀、多个 人做同一件事。
如果不加安全锁，会出现CPU同时执行两个线程，加入安全锁后，便不会再有这种问题，当然效率也会下降，这是不可避免的
同步监视器 :同步监视器可以是任何对象,必须唯一,保证多个线程获得是同一个对象 (锁). 同步监视器的执行过程:
- 第一个线程访问，锁定同步监视器，执行其中代码.
- 第二个线程访问，发现同步监视器被锁定，无法访问.
- 第一个线程访问完毕，解锁同步监视器.
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
public class Demo1 implements Runnable {
static int num = 20;//票数
static Object object = new Object();//static 修饰，在两个保证demo对象时只有一个object对象
@Override
public void run() {
//添加同步锁，保证CPU一次只进行一个线程
while(true){
if(num>0){
print();
}else{
break;
}
}
}
public synchronized void print() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"票数剩余"+num);
num--;
}
}
/*@Override
public void run() {
//添加同步锁，保证CPU一次只进行一个线程
while (true) {
synchronized(object) {//添加随意的一个对象，保证对象只有一个
if (num > 0) {
//增加睡眠程序
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
--num;
System.out.println(Thread.currentThread().getName() + "票数剩余" + num);
} else {
continue;
}
}
}
}
}*/
两种方法都可以
public class Test {
//模拟买票会出现的问题
//票数数static的，但是会出现一个线程还没出来，另一个线程就进去
public static void main(String[] args) {
Demo1 d1 = new Demo1();
Thread thread1 = new Thread(d1,"窗口1");
Thread thread2 = new Thread(d1,"窗口2");
thread1.start();
thread2.start();
}
}
两种方法都可以实现同步锁：
如果用一个类来实现Runnable接口，他就可以用this对象来作synchronized的对象，并且单独写方法，不用加static因为在Test类里面可以只创建一个对象
如果用一个类来继承Thread类，那么就要用static来修饰Object对象，并且单独写方法，要加static因为在这个类里面，调用两个start()，就要创建两个对象，那么安全锁的对象就不熟唯一的了
Lock（锁）
从JDK 5.0开始，Java提供了更强大的线程同步机制-通过显式定义同步锁对象 来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁， 线程开始访问共享资源之前应先获得Lock对象。
synchronized是 隐式加、释放锁。 可以锁代码块，也可以锁方法
Lock是开团显示的加 释放锁，只能锁代码块
public class Demo1 extends Thread{
static Object oba = new Object();
static Object obb = new Object();
boolean flag;//全局变量
public Demo1(boolean flag){//构造方法传值
this.flag = flag;
}
@Override
public void run() {
/** if没有加锁，两个线程都可以进来，一个true，一个false
* 当一个线程进入到oba（true）时，会启动oba锁
* 同时
* 另一个线程进入obb（false），他启动了obb锁
*/
if(flag){
synchronized (oba) {
System.out.println("IF:obA");
synchronized (obb) {
System.out.println("IF:obB");
}
}
/**
* 同时启动两个锁，但是也占用了两个锁
* 导致oba无法进入obb锁
* 另一个obb也无法进入oba锁
* 两个锁同时霸占对方的资源，而且都在等对方放弃自己的资源
* 所以形成了死锁
* 你不放手，他也不放手，一直卡在这，形成阻塞
* 这时候，程序不会报错，也不会运行，就形成了死锁
*/
}else {
synchronized (obb) {
System.out.println("ELSE:obB");
synchronized (oba) {
System.out.println("ELSE:obA");
}
}
}
}
}
public class Test {
public static void main(String[] args) {
Demo1 d1 = new Demo1(true);
Demo1 d2 = new Demo1(false);
d1.start();
d2.start();
}
}
look！程序已锁死
线程通信
先提出一个问题：如何使用两个线程交替打印1-100之间的数字？
我们之前学的线程，尽管加了安全锁，尽管可以安全打印，但是不能做到交叉打印。
线程通讯指的是多个线程通过消息传递实现相互牵制，相互调度，即线程间的相 互作用。
object.notify();//唤醒wait()，并且此线程继续向下执行
object.wait();//阻塞此线程，并且释放安全锁，下一个线程可以进来
public class Demo1 extends Thread{
static int num;
static Object object = new Object();
@Override
public void run() {
while(true) {
synchronized (object) {
object.notify();//唤醒wait()，并且此线程继续向下执行
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num <= 50) {
num++;
System.out.println(Thread.currentThread().getName() +":"+ num);
} else {
break;
}
try {
object.wait();//阻塞此线程，并且释放安全锁，下一个线程可以进来
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public class Test {
public static void main(String[] args) {
Demo1 d1 = new Demo1();
Demo1 d2 = new Demo1();
d1.start();
d2.start();
}
}
升级问题： 生产者(Productor)将产品放在柜台(Counter)，而消费者(Customer)从柜台 处取走产品，生产者一次只能生产固定数量的产品(比如:1）， 这时柜台中不能 再放产品,此时生产者应停止生产等待消费者拿走产品,此时生产者唤醒消费者来 取走产品,消费者拿走产品后,唤醒生产者,消费者开始等待
一共四个类 方法类，两个线程类和一个主类
public class Demo1 {
//add方法和sub方法
static int num = 1;//假设商品的初始量为1
public synchronized void add() {
//生产者
while (true) {
if (num == 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
num++;
System.out.println("生产者生产了一件");
this.notify();
} else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public synchronized void sub() {
//消费者
while (true) {
if (num > 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("消费者消费了一件");
num--;
this.notify();
} else {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public class AddPeople extends Thread{
//消费者
Demo1 demo1;
public AddPeople(Demo1 demo1){
this.demo1 = demo1;
}
@Override
public void run(){
demo1.sub();
}
}
public class SubPeople extends Thread{
//生产者
Demo1 demo1;
public SubPeople(Demo1 demo1){
this.demo1 = demo1;
}
@Override
public void run(){
demo1.add();
}
}
public class Test {
public static void main(String[] args) {
Demo1 demo1 = new Demo1();
AddPeople addPeople = new AddPeople(demo1);
SubPeople subPeople = new SubPeople(demo1);
addPeople.start();
subPeople.start();
}
}
新增创建线程方式
实现Callable接口与使用Runnable相比，Callable功能更强大些.
- 相比run（）方法，可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类，获取返回结果
接收任务：
FutureTask futureTask = new FutureTask(任务);
创建线程：
Thread t = new Thread(futureTask);
t.start();
Integer val = futureTask.get();获得线程call方法的返回值
import java.util.concurrent.Callable;
public class Demo1 implements Callable<Integer> {
//支持泛型结构的多线程，有返回值
@Override
public Integer call() throws Exception {
int sum = 0;//自动装箱
//Integer sum = 0;
for (int i = 0; i < 10; i++) {
sum+=i;
}
return sum;
}
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Demo2 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Demo1 demo1 = new Demo1();
FutureTask futureTask = new FutureTask(demo1);
//需要借助FutureTask类，获取返回结果
Thread thread = new Thread(futureTask);
thread.start();
Integer a = (Integer) futureTask.get();
System.out.println(a);
}
}
852
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
