今天来回顾一下Java多线程,对以往所学做个小总结.<<论语>>有云:温故而知新,可以为师矣.学习过程中更应该去回顾以往的所学所看,及时作总结,这样才可以把自己曾经学到过的东西最大化吸收.
1.进程和线程
1:进程:
是系统进行资源分配和调用的独立单位.
每一个进程都有自己的内存空间和系统资源.
2:线程:
是进程中单个顺序空控制流,是一条执行路径.
单线程:一个进程如果只有一条执行路径,则被称为单线程程序
多线程:一个进程如果有多条执行路径,则成为多线程程序.
2.实现多线程的方式一:继承Thread类
实现步骤:
1:定义一个MyThread类继承Thread类
2:在MyThread类中重写run()方法
3:创建MyThread对象
4:启动线程
定义MyThread类:
public class MyThread extends Thread {
@Override
public void run() {
for(int i = 0;i<=100;i++){
System.out.println(i);
}
}
}
创建MyThread类对象:
public class MyThreadDemo {
public static void main(String[] args) {
//创建MyThread类的对象
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
//run():如果直接启动run()方法,还是按照以前的从上到下的书顺序一次执行,执行完一次,在执行另一个
// my1.run();
// my2.run();
//开启线程
//void start():导致此线程开始执行,Java虚拟机调用此线程的run()方法
my1.start();
my2.start();
}
}
小结:
1:为什么要重写run()方法:因为run() 方法用来封装被线程执行的代码
2:run() 和start() 有什么区别:
run()方法封装线程执行的代码,直接调用,相当于普通的调用
start():启动线程,然后由JVM调用此线程run()方法
3.设置和获取线程名称
方法 | 说明 |
void setName(String name): | 将此线程的名称更改为参数name |
String getName(): | 返回此线程的名称 |
Thread currentThread | 返回当前正在执行的线程对象的引用 |
package test1;
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);
}
}
}
/*
* private static int threadInitNumber;//0
private static synchronized int nextThreadNum() {
return threadInitNumber++;
}
* */
package test1;
public class MyThreadDemo {
public static void main(String[] args) {
//创建MyThread类的对象
// MyThread my1 = new MyThread();
// MyThread my2 = new MyThread();
//run():如果直接启动run()方法,还是按照以前的从上到下的书顺序一次执行,执行完一次,在执行另一个
// my1.run();
// my2.run();
//开启线程
//void start():导致此线程开始执行,Java虚拟机调用此线程的run()方法
//void setName(String name):将此线程的名称更改为参数name
// my1.setName("高铁");
// my2.setName("飞机");
//有参构造方法,进行赋值
//Thread(String name);
MyThread my1 = new MyThread("飞机");
MyThread my2 = new MyThread("高铁");
my1.start();
my2.start();
System.out.println("=================");
//Thread currentThread返回当前正在执行的线程对象的引用
System.out.println(Thread.currentThread().getName());
}
}
4.线程的优先级
线程的调度:
1.有两种调度方式:
1:分时调度模型,所有的线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间.
2:抢占式调度模型,优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取CPU的时间相对多些.
2.Java使用的是抢占式调度模型
3.随机性
假如计算机只有一个CPU,那么CPU在某一刻只能执行一条指令,线程只有得到CPU的时间,也就是使用权,才可以执行指令,所以多线程程序的执行是有随机性的,因为谁抢到CPU的使用权是不一定的
5.优先级相关方法
方法名 | 说明 |
final int getPriority() | 获取当前线程的优先级 |
final void setPriority (int priority) | 更改此线程的优先级,线程默认优先级是5,线程优先级范围是1-10 |
package test2;
public class MyThreadDemo {
public static void main(String[] args) {
MyThread my1 = new MyThread();
MyThread my2 = new MyThread();
MyThread my3 = new MyThread();
my1.setName("高铁");
my2.setName("飞机");
my3.setName("汽车");
//final int getPriority()获取当前线程的优先级
System.out.println(my1.getPriority());//5
System.out.println(my2.getPriority());//5
System.out.println(my3.getPriority());//5
//报错:.IllegalArgumentException
//my1.setPriority(1000);
System.out.println(Thread.MAX_PRIORITY);//10
System.out.println(Thread.MIN_PRIORITY);//1
System.out.println(Thread.NORM_PRIORITY);//5
//设置正确的优先级
my1.setPriority(5);
my2.setPriority(10);
my3.setPriority(1);
my1.start();
my2.start();
my3.start();
}
}
6.线程控制
方法名 | 说明 |
static void sleep(long mills) | 使当前正在执行的线程停留(暂停执行)指定的毫秒数 |
void join() | 等待这个线程死亡 |
void setDaemon( boolean on ) | 将此线程标记为守护线程,当运行的线程都是守护线程时,Java虚拟机将退出 |
1:sleep:
package test3;
public class ThreadSleep extends Thread {
@Override
public void run() {
for(int i = 0;i<10;i++){
System.out.println(getName()+":"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package test3;
public class ThreadSleepDemo {
public static void main(String[] args) {
ThreadSleep ts1 = new ThreadSleep();
ThreadSleep ts2 = new ThreadSleep();
ThreadSleep ts3 = new ThreadSleep();
ts1.setName("曹操");
ts2.setName("刘备");
ts3.setName("孙权");
ts1.start();
ts2.start();
ts3.start();
}
}
2:join:
package test4;
public class ThreadJoin extends Thread {
@Override
public void run() {
for(int i = 0;i<10;i++){
System.out.println(getName()+":"+i);
}
}
}
package test4;
public class ThreadJoinDemo {
public static void main(String[] args) {
ThreadJoin tj1 = new ThreadJoin();
ThreadJoin tj2 = new ThreadJoin();
ThreadJoin tj3 = new ThreadJoin();
tj1.setName("康熙");
tj2.setName("四阿哥");
tj3.setName("八阿哥");
tj1.start();
try {
tj1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
tj2.start();
tj3.start();
}
}
3:Daemon:
package test5;
public class ThreadDaemon extends Thread {
@Override
public void run() {
for(int i = 0;i<100;i++){
System.out.println(getName()+":"+i);
}
}
}
package test5;
public class ThreadDaemonDemo {
public static void main(String[] args) {
ThreadDaemon td2 =new ThreadDaemon();
ThreadDaemon td3 =new ThreadDaemon();
td2.setName("张飞");
td3.setName("关羽");
//设置刘备为主线程
Thread.currentThread().setName("刘备");
//设置守护线程
td2.setDaemon(true);
td3.setDaemon(true);
td2.start();
td3.start();
for(int i = 0;i<10;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
7.实现线程的方式二:实现Runnable接口
Thread的构造方法:
Thread(Runnable target):分配一个新的Thread对象
Thread(Runnable target,String name):分配一个新的Thread对象
实现步骤:
1:定义一个类MyRunnable实现Runnable接口
2:在MyRunnable类中重写run()方法
3:创建MyRunnable类的对象
4:创建Thread类的对象,把MyRunnable对象作为构造方法的参数
5:启动线程
public class MyRunnable implements Runnable {
@Override
public void run() {
for(int i = 0;i<100;i++){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
public class MyRunnableDemo {
public static void main(String[] args) {
//创建MyRunnable类的对象
MyRunnable my= new MyRunnable();
//Thread(Runnable target):分配一个新的Thread对象
/*Thread t1 = new Thread(my);
Thread t2 = new Thread(my);
t1.setName("飞机");
t2.setName("高铁");*/
//Thread(Runnable target,String name):分配一个新的Thread对象
Thread t1 = new Thread(my,"飞机");
Thread t2 = new Thread(my,"高铁");
t1.start();
t2.start();
}
}
8.线程同步
某电影院目前正在上映某国产大片,共有100张票,而他只有三个窗口卖票,请设计一个程序模拟该电影院卖票
实现步骤:
1:定义一个类SellTicket 实现Runnable接口,在里面定义一个成员变量:private int tickets=100;
2: 在SellTicket类中重写run()方法实现卖票,
3:判断票数是否大于0,就卖,并告知在哪个窗口卖的
4:卖了票之后,总票数要-1
5:票没有了,也有可能有人来问,所以这里要设置成死循环
6:定义一个测试类SellTicktDemo,俩面设置一个main方法,
7:创建SellTicket类的对象
8:创建三个Thread类的对象,把SellTicket对象作为构造方法的参数,并给出对应窗口的名称
9:启动线程
package test7;
public class SellTicket implements Runnable {
private int tickets=100;//初始有100张票
@Override
public void run() {
while(true){
if(tickets>0){
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}
}
}
package test7;
public class SellTicketDemo {
public static void main(String[] args) {
SellTicket st = new SellTicket();
//创建Thread类对象
Thread t1 = new Thread(st,"窗口一");
Thread t2 = new Thread(st,"窗口二");
Thread t3 = new Thread(st,"窗口三");
t1.start();
t2.start();
t3.start();
}
}
卖票案例的问题
相同的票出现了多次
出现负数票
package test7;
public class SellTicket implements Runnable {
private int tickets=100;//初始有100张票
@Override
public void run() {
//相同的票出现
/*while(true){
//t1,t2,t3
//假设t1抢到了CPU的执行权
if(tickets>0){
//通过sleep()方法来模拟出票
try {
Thread.sleep(100);
//t1线程休息
//t2又抢到了CPU的使用权,t2线程开始执行,执行到执行到这里,t2线程休息
//t3又抢到了CPU的使用权,t3线程开始,并执行到这里,t3线程开始休息
} catch (InterruptedException e) {
e.printStackTrace();
}
//假设按照顺序醒过来
//t1抢到了CPU的使用权,在控制台输出:窗口1正在出售第100张票
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
//t2抢到CPU的使用权,在控制台输出:窗口二正在出售第100张票
//t3抢到了CPU的使用权,在控制台输出:窗口三正在出售第100张票
tickets--;
//如果这三个线程还是按照顺序来,这里就实行了三次--操作,最终票97
}
}*/
//出现了负数的票
while(true){
//ticket=1
//t1,t2,t3
//假设t1抢到了CPU的执行权
if(tickets>0){
//通过sleep()方法来模拟出票
try {
Thread.sleep(100);
//t1线程休息
//t2又抢到了CPU的使用权,t2线程开始执行,执行到执行到这里,t2线程休息
//t3又抢到了CPU的使用权,t3线程开始,并执行到这里,t3线程开始休息
} catch (InterruptedException e) {
e.printStackTrace();
}
/*
* 假设线程按照顺序醒过来,
* t1抢到CPU的使用权,在控制台输出:窗口一正在出售第1张票
* t1又抢到了CPU的使用权,就会执行tickets--操作,ticket=0
* t2抢到CPU的使用权,在控制台输出:窗口一正在出售第0张票
* t2又抢到了CPU的使用权,就会执行tickets--操作,ticket=-1
* t3抢到CPU的使用权,在控制台输出:窗口一正在出售第-1张票
* t3又抢到了CPU的使用权,就会执行tickets--操作,ticket=-2
* */
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}
}
}
同步代码块解决数据安全问题
安全问题出现的条件:
1:是多线程的环境
2:有共享的数据
3:有多条语句操作共享数据
如何解决多线程安全问题呢?
基本思想:让程序没有安全问题的环境
怎么实现:
把多条语句操作共享数据的代码给锁起来,让任意时刻只能有一个线程执行即可
Java提供了同步代码块的方式来解决
同步代码块格式:
synchronized(任意对象){
多条语句操作共享数据的代码块
}
synchronized(任意对象):就相当于给代码加锁了,把任意对象就可以堪称一把锁
同步数据的好处和弊端:
好处:解决了多线程的数据安全问题
弊端:当线程很多的时候,因为每个线程都会上锁,这样就很消耗资源,无形中会降低程序的运行效率
package test8;
public class SellTicket implements Runnable {
private int tickets=100;//初始有100张票
private 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关键字加到方法上
修饰符 synchronized 返回值类型 方法名(方法参数){
方法体;
}
同步方法的锁对象是什么?
this
静态同步方法:
同步静态方法:就是把synchronized关键字加到静态方法上
修饰符 static synchronized 返回值类型 方法名(方法参数){
方法体;
}
package test8;
public class SellTicket implements Runnable {
private static int tickets=100;//初始有100张票
private Object obj = new Object();
@Override
public void run() {
while(true){
sellTicket();
}
}
//同步方法:
/* private synchronized void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}*/
//静态同步方法
private static synchronized void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}
}
lock锁
虽然我们可以理解同步代码块和同步方法锁对象问题,但是我们并没有直接看到在哪里上了锁,在哪里释放了锁,为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象 :LOCK
LOCK是接口不能直接实例化,这里采用的是他的实现类ReentrantLock来实例化
ReentrantLock的构造方法:
ReentrantLock():创建一个ReentrantLock的实例
加锁和解锁的方法
void lock():获取锁
void unlock():释放锁
package test8;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SellTicket implements Runnable {
private static int tickets=100;//初始有100张票
private Object obj = new Object();
private Lock lock = new ReentrantLock();
@Override
public void run() {
while(true){
//获取锁
try{
lock.lock();
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
//同步方法:
/* private synchronized void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}*/
//静态同步方法
/* private static synchronized void sellTicket(){
if(tickets>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
tickets--;
}
}*/
}
到这里,多线程的基础知识就讲解完毕