程序、进程和线程区别
程序:是为完成特定任务,用某种语言编写的一组指令的集合,即指一段静态的代码,静态对象;
进程:是指一个内存中运行的应用程序,每个进程都有一个独立的内存空间;
线程:是进程中的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行. 一个进程最少有一个线程。
线程调度
分时调度:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间;
抢占式调度:优先让优先级高的线程使用 CPU,如果线程的优先级相同,那么会随机选择一个(线程随机;
Java使用的为抢占式调度。
CPU使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核新而言,某个时刻,只能执行一个线程,而 CPU的在多个线程间切换速度相对我们的感觉要快,看上去就是在同一时刻运行。 其实,多线程程序并不能提高程序的运行速度,但能够提高程序运行效率,让CPU的 使用率更高。
并发和并行
并发:指两个或多个事件在同一个时间段内发生;
并行:指两个或多个事件在同一时刻发生(同时发生)。
Java多线程的实现方式
1.继承Thread类
1)自定义线程类
2)重写run方法,编写线程执行体
3)创建线程对象,调用start()方法执行启动线程
package tiz.test.多线程;
//利用Thread来实现多线程,构造自己的Thread继承自Thread
//重写run方法,就是一个子线程
public class myThread extends Thread{
@Override
public void run() {
for (int i =0;i<10;i++){
System.out.println("锄禾日当午"+i);
}
}
}
package tiz.test.多线程;
/**
* 多线程的实现
*@author Tiz_liu
*/
//每个线程都有自己的栈空间,共用一份堆内存。
public class Demo1 {
public static void main(String[] args) {
myThread m =new myThread();
m.start();//调用start方法,而不是run
for (int i =0;i<10;i++){
System.out.println("汗滴禾下土"+i);
}
}
}
2.实现Runnable接口
1)定义MyRunnable类实现Runnable接口
2)实现run()方法,编写线程执行体
3)创建线程对象,调用start()方法启动线程
package tiz.test.多线程;
public class MyRunnable implements Runnable {
@Override
public void run() {
for (int i =0;i<10;i++){
System.out.println("床前明月光"+i);
}
}
}
package tiz.test.多线程;
public class Demo2 {
/**
* 多线程技术
* 实现runnnable与继承Thread的优点
* 1.通过创建任务,然后给线程分配的方式来实现多线程,更适合多个线程同时执行相同任务的情况
* 2.可以避免单继承带来的局限性
* 3.任务与线程分类,提高了程序的健壮性
* 4.后续的线程池技术,接受Runnable类型的任务,不接受Thread类型的线程
*/
public static void main(String[] args) {
//1.创建一个任务
MyRunnable r = new MyRunnable();
//2.创建一个线程
Thread t = new Thread(r);
//3.执行线程
t.start();
for (int i =0;i<10;i++){
System.out.println("疑是地上霜"+i);
}
}
}
3.实现Callable接口
多线程不安全解决方案
1.同步代码块
同步块:synchronized (o) {}
package tiz.test.多线程;
public class Demo6_1 {
//线程安全不安全
//解决方案1.同步代码块
//格式:synchronized(锁对象){}
public static void main(String[] args) {
Ticket t = new Ticket();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
static class Ticket implements Runnable{
//票数
private int count = 10;
private Object o = new Object();
@Override
public void run() {
while (true){
synchronized (o){
//卖票
if(count>0){
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"出票成功,余票"+count);
}else{
break;
}
}
}
}
}
}
2.同步方法
public synchronized void method(int args){}
package tiz.test.多线程;
public class Demo6_2 {
//线程安全不安全
//解决方法2.同步方法
public static void main(String[] args) {
Ticket t = new Ticket();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
static class Ticket implements Runnable{
//票数
private int count = 10;
@Override
public void run() {
//卖票
while (true){
boolean flag = safe();
if (!flag){
break;
}
}
}
public synchronized boolean safe(){//同步方法
if(count>0){
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"出票成功,余票"+count);
return true;
}else{
return false;
}
}
}
}
3.显式锁Lock
package tiz.test.多线程;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo6_3 {
//线程安全不安全
//解决方法3.显示锁Lock 子类 ReentrantLock
public static void main(String[] args) {
Ticket t = new Ticket();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
static class Ticket implements Runnable{
//票数
private int count = 10;
private Lock l = new ReentrantLock();
@Override
public void run() {
while (true){
//卖票
l.lock();
if(count>0){
System.out.println("正在准备卖票");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
count--;
System.out.println(Thread.currentThread().getName()+"出票成功,余票"+count);
}else{
break;
}
l.unlock();
}
}
}
}
显式锁和隐式锁
隐式锁:synchronized;
显式锁:lock
所谓的显示和隐式就是在使用的时候,使用者要不要手动写代码去获取锁和释放锁的操作。
在使用sync关键字的时候,我们使用者根本不用写其他的代码,然后程序就能够获取锁和释放锁了。那是因为当sync代码块执行完成之后,系统会自动的让程序释放占用的锁。Sync是由系统维护的,如果非逻辑问题的话话,是不会出现死锁的。
在使用lock的时候,我们使用者需要手动的获取和释放锁。如果没有释放锁,就有可能导致出现死锁的现象。手动获取锁方法:lock.lock()。释放锁:unlock方法。需要配合tyr/finaly语句块来完成。
公平锁和非公平锁
是否按照申请锁的顺序去获得锁
Sync;非公平锁
lock:两者都可以的。默认是非公平锁。在其构造方法的时候可以传入Boolean值。
true:公平锁
false:非公平锁
线程池
如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低 系统的效率,因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容器,池中的线程可以反复使用,省去了频繁创建线程对象的操作,节省了大量的时间和资源。
线程池的优点
降低资源消耗。
提高响应速度。
提高线程的可管理性。