JAVA多线程
多线程的基本概念
线程指进程中的一个执行场景，也就是执行流程，那么进程和线程有什么区别呢？
• 每个进程是一个应用程序，都有独立的内存空间
• 同一个进程中的线程共享其进程中的内存和资源（共享的内存是堆内存和方法区内存，栈内存不共享，每个线程有自己的。）
什么是进程？
一个进程对应一个应用程序。例如：在windows操作系统启动Word就表示启动了一个
进程。在java的开发环境下启动JVM，就表示启动了一个进程。现代的计算机都是支持多
进程的，在同一个操作系统中，可以同时启动多个进程。
多进程有什么作用？
单进程计算机只能做一件事情。
玩电脑，一边玩游戏（游戏进程）一边听音乐（音乐进程）。
对于单核计算机来讲，在同一个时间点上，游戏进程和音乐进程是同时在运行吗？不是。
因为计算机的CPU只能在某个时间点上做一件事。由于计算机将在“游戏进程”和“音乐
进程”之间频繁的切换执行，切换速度极高，人类感觉游戏和音乐在同时进行。
多进程的作用不是提高执行速度，而是提高CPU的使用率。
进程和进程之间的内存是独立的。
什么是线程？
线程是一个进程中的执行场景。一个进程可以启动多个线程。
多线程有什么作用？
多线程不是为了提高执行速度，而是提高应用程序的使用率。
线程和线程共享“堆内存和方法区内存”，栈内存是独立的，一个线程一个栈。
可以给现实世界中的人类一种错觉：感觉多个线程在同时并发执行。
java程序的运行原理？
java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，表示启动了一个进程。该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法。所以main方法运行在主线程中。在此之前的所有程序都是单线程的。
线程生命周期
线程是一个进程中的执行场景,一个进程可以启动多个线程
就绪：执行start后
运行：占用CPU时间
阻塞：执行了wait语句、执行了sleep语句和等待某个对象锁，等待输入的场合
终止：退出run()方法
多线程不是为了提高执行速度,而是提高应用程序的使用率.
线程和线程共享”堆内存和方法区内存”.栈内存是独立的,一个线程一个栈.
可以给现实世界中的人类一种错觉:感觉多线程在同时并发执行.
很多人都对其中的一些概念不够明确，如同步、并发等等，让我们先建立一个数据字典，以免产生误会。
• 多线程：指的是这个程序（一个进程）运行时产生了不止一个线程
• 并行与并发：
•
o 并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
•
o 并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。
线程安全：经常用来描绘一段代码。指在并发的情况之下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可。反过来，线程不安全就意味着线程的调度顺序会影响最终结果，如不加事务的转账代码：
voidtransferMoney(Userfrom,Userto,floatamount){
to.setMoney(to.getBalance()+amount);
from.setMoney(from.getBalance()-amount);
}
同步：Java中的同步指的是通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时，提高性能，才是优秀的程序。线程安全的优先级高于性能。
Java命令会启动Java虚拟机,启动JVM,等于启动了一个应用程序,表示启动了一个进程,该进程会自动启动一个”主线程”,
然后主线程去调用某个类的main()方法,所以main()方法运行在主线程中.
线程的调度模型分为:分时调度模型和抢占式调度模型,Java使用抢占式调度模型
通常我们的计算机只有一个CPU，CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。在单CPU的机器上线程不是并行运行的，只有在多个CPU上线程才可以并行运行。Java虚拟机要负责线程的调度，取得CPU的使用权，目前有两种调度模型：分时调度模型和抢占式调度模型，Java使用抢占式调度模型。分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一些。
分时调度模型:所有线程轮流使用CPU的使用权,平均分配每个线程占用CPU的时间片
抢占式调度模型:优先让优先级高的线程使用CPU,如果线程的优先级相同,那么会随机选择一个,优先级高的线程获取的CPU时间片相对多一些.
publicclassThreadTest{
publicstaticvoidmain(String[]args){
ThreadTest1();
//ThreadTest2();
//ThreadTest3();
//ThreadTest4();
//ThreadTest5();
}
/**
*三个方法:获取当前线程对象:Thread.currentThread();给线程起名:t1.setName("t1");获取线程的名字:
*t.getName();
*/
privatestaticvoidThreadTest1(){
Threadt=Thread.currentThread();//t保存的内存地址指向的线程为"主线程"
System.out.println(t.getId());
Threadt1=newThread(newProcessor1());
//给线程起名
t1.setName("t1");
t1.start();
Threadt2=newThread(newProcessor1());
t2.setName("t2");
t2.start();
}
/**
*线程优先级高的获取的CPU时间片相对多一些优先级:1-10最低:1最高:10默认:5
*/
privatestaticvoidThreadTest2(){
Threadt1=newProcessor2();
Threadt2=newProcessor2();
t1.setName("t1");
t2.setName("t2");
System.out.println(t1.getPriority());
System.out.println(t2.getPriority());
t1.setPriority(1);
t2.setPriority(10);
t1.start();
t2.start();
}
/**
*1.Thread.sleep(毫秒);2.sleep方法是一个静态方法3.该方法的作用:阻塞当前线程,腾出CPU,让给其它线程
*/
privatestaticvoidThreadTest3(){
Threadt=newThread(newProcessor3());
t.start();
for(inti=0;i<11;i++){
System.out.println(Thread.currentThread().getName()+"========>"
+i);
try{
t.sleep(5000);//等同于Thread.sleep(5000);阻塞的还是当前线程,和t线程无关.
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
/**
*某线程正在休眠,如何打断它的休眠以下方式依靠的是异常处理机制
*/
privatestaticvoidThreadTest4(){
try{
Threadt=newThread(newProcessor4());
t.start();
Thread.sleep(5000);//睡5s
t.interrupt();//打断Thread的睡眠
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
/**
*如何正确的更好的终止一个正在执行的线程需求:线程启动5s之后终止.
*/
privatestaticvoidThreadTest5(){
Processor5p=newProcessor5();
Threadt=newThread(p);
t.start();
//5s之后终止
try{
Thread.sleep(5000);
p.isRun=false;
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}
classProcessor1implementsRunnable{
@Override
publicvoidrun(){
Threadt=Thread.currentThread();//t保存的内存地址指向的线程为"t1线程对象"
System.out.println(t.getName());
System.out.println(t.getId());
}
}
classProcessor2extendsThread{
@Override
publicvoidrun(){
for(inti=0;i<50;i++){
System.out.println(Thread.currentThread().getName()
+"----------->"+i);
}
}
}
classProcessor3implementsRunnable{
/**
*Thread中的run方法不能抛出异常,所以重写runn方法之后,在run方法的声明位置上不能使用throws
*所以run方法中的异常只能try...catch...
*/
@Override
publicvoidrun(){
for(inti=0;i<11;i++){
System.out.println(Thread.currentThread().getName()+"========>"
+i);
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}
classProcessor4implementsRunnable{
@Override
publicvoidrun(){
try{
Thread.sleep(1000000000);
System.out.println("能否执行这里");
}catch(InterruptedExceptione){
e.printStackTrace();
}
for(inti=0;i<11;i++){
System.out.println(Thread.currentThread().getName()+"========>"
+i);
}
}
}
classProcessor5implementsRunnable{
booleanisRun=true;
@Override
publicvoidrun(){
for(inti=0;i<11;i++){
if(isRun){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+"========>"+i);
}
}
}
}
线程优先级
线程优先级主要分三种：MAX_PRIORITY(最高);MIN_PRIORITY（最低级）NORM_PRIORITY(标准)默认
//设置线程的优先级，线程启动后不能再次设置优先级
//必须在启动前设置优先级
//设置最高优先级
t1.setPriority(Thread.MAX_PRIORITY);
sleep
publicclassSleepTest{
publicstaticvoidmain(String[]args){
System.out.println("Wait");
//让主线程等待5秒再执行
Wait.bySec(5);
//提示恢复执行
System.out.println("start");
}
}
classWait{
publicstaticvoidbySec(longs){
//sleeps个1秒
for(inti=0;i<s;i++){
System.out.println(i+1+"秒");
try{
//sleep1秒
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}
停止一个线程
如果我们的线程正在睡眠，可以采用interrupt进行中断
通常定义一个标记，来判断标记的状态停止线程的执行
yield
它与sleep()类似，只是不能由用户指定暂停多长时间，并且yield()方法只能让同优先级的线程有执行的机会,采用yieid可以将CPU的使用权让给同一个优先级的线程
publicclassYieldTest{
publicstaticvoidmain(String[]args){
FirstThreadmt=newFirstThread();
SecThreadmnt=newSecThread();
mt.start();
mnt.start();
}
}
classFirstThreadextendsThread{
publicvoidrun(){
for(inti=0;i<5;i++){
System.out.println("第一个线程的第"+(i+1)+"次运行");
Thread.yield();//暂停线程
}
}
}
classSecThreadextendsThread{
publicvoidrun(){
for(inti=0;i<5;i++){
System.out.println("第二个线程的第"+(i+1)+"次运行");
Thread.yield();
}
}
}
join
当前线程可以调用另一个线程的join方法，调用后当前线程会被阻塞不再执行，直到被调用的线程执行完毕，当前线程才会执行
publicclassJoinTestextendsThread{
publicJoinTest(Stringname){
super(name);
}
publicvoidrun(){
for(inti=0;i<5;i++)
System.out.println(getName()+""+i);
}
publicstaticvoidmain(String[]args){
for(inti=0;i<10;i++){
if(i==5){
JoinTesttempjt=newJoinTest("半路加入的线程");
try{
tempjt.start();
tempjt.join();
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+""+i);
}
}
}
synchronized
线程同步，指某一个时刻，指允许一个线程来访问共享资源，线程同步其实是对对象加锁，如果对象中的方法都是同步方法，那么某一时刻只能执行一个方法，采用线程同步解决以上的问题，我们只要保证线程一操作s时，线程2不允许操作即可，只有线程一使用完成s后，再让线程二来使用s变量
• 异步编程模型:t1线程执行t1的,t2线程执行t2的,两个线程之间谁也不等谁.
• 同步编程模型:t1线程和t2线程执行,t2线程必须等t1线程执行结束之后,t2线程才能执行,这是同步编程模型.
•
• 什么时候要用同步呢?为什么要引入线程同步呢?
• 1.为了数据的安全,尽管应用程序的使用率降低,但是为了保证数据是安全的,必须加入线程同步机制.
• 线程同步机制使程序变成了(等同)单线程.
• 2.什么条件下要使用线程同步?
• 第一:必须是多线程环境
• 第二:多线程环境共享同一个数据.
• 第三:共享的数据涉及到修改操作.
//synchronized是对对象加锁
//采用synchronized同步最好只同步有线程安全的代码
//可以优先考虑使用synchronized同步块
//因为同步的代码越多，执行的时间就会越长，其他线程等待的时间就会越长
//影响效率
publicclassTestWithdrawal{
publicstaticvoidmain(String[]args){
//创建两个线程
TestAccountr=newTestAccount();
Threadone=newThread(r);
Threadtwo=newThread(r);
one.setName("张三");
two.setName("张三的妻子");
//启动线程
one.start();
two.start();
}
}
classAccount{
privateintbalance=500;//余额
publicintgetBalance(){
returnbalance;
}
//取款
publicvoidwithdraw(intamount){
balance=balance-amount;
}
}
classTestAccountimplementsRunnable{
//所有用TestAccount对象创建的线程共享同一个帐户对象
privateAccountacct=newAccount();
publicvoidrun(){
for(inti=0;i<5;i++){
makeWithdrawal(100);//取款
if(acct.getBalance()<0){
System.out.println("账户透支了!");
}
}
}
privatevoidmakeWithdrawal(intamt){
synchronized(acct){
if(acct.getBalance()>=amt){
System.out.println(Thread.currentThread().getName()+"准备取款");
try{
Thread.sleep(500);//0.5秒后实现取款
}catch(InterruptedExceptionex){
}
//如果余额足够，则取款
acct.withdraw(amt);
System.out.println(Thread.currentThread().getName()+"完成取款,余额："+acct.getBalance());
}else{
//余额不足给出提示
System.out.println("余额不足以支付"
+Thread.currentThread().getName()+"的取款，余额为"
+acct.getBalance());
}
}
}
}
死锁
publicclassDeadLock{
publicstaticvoidmain(String[]args){
Objecto1=newObject();
Objecto2=newObject();
Threadt1=newThread(newT1(o1,o2));
Threadt2=newThread(newT2(o1,o2));
t1.start();
t2.start();
}
}
classT1implementsRunnable{
Objecto1;
Objecto2;
T1(Objecto1,Objecto2){
this.o1=o1;
this.o2=o2;
}
@Override
publicvoidrun(){
synchronized(o1){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
synchronized(o2){
}
}
}
}
classT2implementsRunnable{
Objecto1;
Objecto2;
T2(Objecto1,Objecto2){
this.o1=o1;
this.o2=o2;
}
@Override
publicvoidrun(){
synchronized(o2){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione){
e.printStackTrace();
}
synchronized(o1){
}
}
}
}
守护线程
从线程分类上可以分为：用户线程（以上讲的都是用户线程），另一个是守护线程。守护线程是这样的，所有的用户线程结束生命周期，守护线程才会结束生命周期，只要有一个用户线程存在，那么守护线程就不会结束，例如java中著名的垃圾回收器就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。
• 其它所有的用户线程结束,则守护线程退出!
• 守护线程一般都是无限执行的.
publicclassDaemonThread{
publicstaticvoidmain(String[]args)throwsInterruptedException{
Threadt1=newThread(newRunnable2());
t1.setName("t1");
//将t1这个用户线程修改成守护线程.在线程没有启动时可以修改以下参数
t1.setDaemon(true);
t1.start();
//主线程
for(inti=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"----->"+i);
Thread.sleep(1000);
}
}
}
classRunnable2implementsRunnable{
@Override
publicvoidrun(){
inti=0;
while(true){
i++;
System.out.println(Thread.currentThread().getName()+"-------->"
+i);
try{
Thread.sleep(500);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
}
设置为守护线程后，当主线程结束后，守护线程并没有把所有的数据输出完就结束了，也即是说守护线程是为用户线程服务的，当用户线程全部结束，守护线程会自动结束
Timer.schedule()
/**
*关于定时器的应用作用:每隔一段固定的时间执行一段代码
*/
publicclassTimerTest{
publicstaticvoidmain(String[]args)throwsParseException{
//1.创建定时器
Timert=newTimer();
//2.指定定时任务
t.schedule(newLogTimerTask(),newSimpleDateFormat(
"yyyy-MM-ddHH:mm:ssSSS").parse("2017-06-2914:24:00000"),
10*1000);
}
}
//指定任务
classLogTimerTaskextendsTimerTask{
@Override
publicvoidrun(){
System.out.println(newSimpleDateFormat("yyyy-MM-ddHH:mm:ssSSS")
.format(newDate()));
}
}
我是melon，一个10年编程老司机。Q我3474203856。 给melon留言或者说明是看到文章过来的。所有相关技术问题都可以一起寻找到答案。
