线程相关

并发:

-多个不同的软件同时运行

         Window/Linux等操作系统,同时管理多个软件并发执行,

         如eclipse,chrome,各类游戏等软件同时运行

-一个软件被多个用户同时请求,

         多个浏览器,用户可以请求淘宝,做结算操作,支付操作

         等价于结算操作和支付操作在服务端被多次运行

总结:并发就是

         多个软件同时运行,

         一个软件被运行多次

         就是要cpu不停的工作,来提高cpu的利用率

计算机如何做到并发:  (前提:一台计算机中有一块cpu,一个核)

         分析硬件cpu的处理:

                   在cpu的某个时间点上,只有一个程序能够执行

                   为了能做到并发,把cpu的时间分成若干片段,

                   (时间片的划分原则是由操作系统定义的)

                   每个小的时间片只能执行一个程序

                   时间片到了就把程序强制离开

                   在从内存中选出下一个程序继续运行,以此往复

                   看似在一段时间内,多个程序在同时运行

分析软件:

         一个软件动辄几百兆,或上G,一个软件不能整个存储到内存中的

         进程:把大的软件分割成多个小的程序段,程序段称之为进程

多个大的程序要运行,先把程序分割成小的程序段,把内个程序段的前一部分的若干程序段加载到内存

内存中放置了多个程序的多个程序段,这些程序段根据优先级排队

CPU从队头获取下一个程序段运行

大量的进程程序段,在频繁切换cpu的时候会占用cpu的时间去做弹栈和压栈的工作,同时需要存储部分内存去存储栈中的数据

         总结:

                   要想做到并发

1. cpu要划分片段

2. 程序要画进程

3. 由操作系统画片段(时间片和程序段)

因为并发导致占用cpu的时间和内存,那么就把进程再次划分成为更小的程序片段,叫做线程(Thread),一个进程包含一个或者多个线程,是能够执行的独立单位

总结:

         Cpu画片段

         程序画进程段

         进程划为线程

         其实cpu真正运行的是线程

         尽量提高cpu的利用率,减少内存的使用

进程还拥有一个私有的虚拟内存地址,该空间只能被它包含的线程访问,

线程只能归属到某一个进程,并且他只能访问该进程的所有资源,当操作系统创建了一个进程之后,该进程会自动申请变成一个名为主线程或者首先线程

 

同类的多线程共享一块内存空间和一组资源,

线程的本身游戏一个供程序执行的堆栈,线程切换时,负荷小,线程被称之为轻负荷进程

一个进程包含多个线程

 

进程和线程的区别:

         一个进程至少有一个线程

         线程的划分尺度小于进程, 使得多个线程并发性高,另外进程指定的过程中拥有独立的内存单元,而多个线程共享进程的内存空间,提高程序的运行效率

         线程的执行过程中,与进程的区别在于每一个独立的线程有一个程序的运行入口,顺序执行序列和程序出口

         但是线程不能独立运行,必须依存于应用程序

         由应用程序提供对线程的控制

线程的应用场景:

         线程通常用于一个应用程序中需要同时完成多个任务的情况,

         可以将每个任务定义一个线程,使得他们可以一同工作

         可以用于单一线程中完成,但是使用多线程可以更快的完成所需要的功能

 

线程的使用:在java中通过java的api方法做线程编程

方案一: 继承Thread类

         Thread类:

                   此类是线程类,其每一个实例表示一个可并发运行的线程

                   我们可以通过继承此类并重写run方法来定义一个具体线程

                   在run方法中体现的是线程的功能,(有线程的入口和出口)

 

                   启动线程是调用县城对象的start()方法,不是直接调用run方法

start()方法将线程调入线程调度使当前线程可以并发运行,当线程获取到cpu的时间片时,开始自动运行run方法中的逻辑代码

方案二:实现Runnable接口

         Runnable接口:

                   实现此接口并重写run方法来定义线程类,然后创建线程的时候,

                   将Runnable接口的实例出入并启动线程

                   这样做的好处就是可以将线程和线程要执行的任务逻辑分开

                   减少耦合,同时java是单继承,定义一个类实现Runnable接口,这样能更好的

                   实现其他接口和继承父类

 

做线程的目的:

         实际上是为了作多线程,多线程的目的是为了能并发,能并发的目的是为了提高cpu的利用率

 

多线程的两种方式:

1. 多个线程共享一个run方法

2. 多个线程可以每个线程一个run方法

1和2组合在一起也是多线程

Java程序员可以写线程,不需要程序员关心线程在哪个进程里,

线程的实现方式:

继承Thread类

         public class MyThread extends Thread{

                   public void run(){

         //线程入口

//线程的业务逻辑/任务

//线程出口

}

}

使用时:

         MyThread mt=new MyThread();

         mt.start();//调用重写的run方法,实际上是多态

实现Runnable接口:

         public void class RunLuoJi implements Runnable{

                   public void run(){

//线程入口

//线程的业务逻辑/任务

//线程出口

}

         }

         使用时:
         Thread  t=new Thread(new RunLuoJi);

         t.start();//执行的是Thread里的方法,由Thread的run调用接口的run方法

 

线程的状态:

创建线程的对象: 创建态  Thread t=new Thread();

创建完线程对象:  就绪态  t.start();//排到线程队列中去,不一定马上获取到CPU去执行run

获取到CPU资源  执行态   执行run(),线程出队列

执行到某一个时间点是由阻塞态  从CPU中下来//io,sleep,wait等阻塞

如果正常执行完run方法,有结束态(消亡态),等待GC回收

 

线程状态的转化:

创建态à就绪态

就绪态à执行态

执行态à阻塞态(挂起)

执行态à就绪态

阻塞态à就绪态

执行态à消亡态

 

结论:

1. 根据业务,要考虑有多少个业务逻辑,就写多少个run

2. 每个run要执行多少次

3. 执行每一次run的时候,run是否使用数据

 

用内部类创建线程对象

         通常,我们可以用匿名内部类的方式创建线程,使用该方式可以简化编写代码的复杂度

当一个线程仅需要一个实例时,我们通常使用如下方式:

方式一:

         实现类是匿名的,对象有名

         Thread t=new Thread(){

         public void run(){

System.out.println(“run方法”);

}

}

         t.start();

方式二:

         实现类是匿名的,对象也是匿名的

         new Thread(new Runnable{

                   public void run(){

         System.out.println(“run方法”);

 

}

}).start();

方式三:

实现类是匿名的,对象不是匿名的,有对象名(Runnable接口的子实现)

Runnable r=new Runnable(){

         public void run(){

System.out.println(“run方法”);

}

}

Thread t=new Thread(r);

t.start();

方式四:

对象时匿名的,实现类也是匿名的

new Thread({

         public void run(){

System.out.println(“run方法”);

}

}).start();

方式五:

实现类是匿名的,对象是有名的

Thread t=new Thread(new Runnable{

         public void run(){

                   System.out.println(“run方法”);

}

});

t.start();

 

创建线程对象的几种方式的优缺点:

1. 继承自Thread类,重写run方法

优点:在当前线程类中,可以获取到run方法并重写

           同时在当前线程类中也可以访问Thread类中的方法

缺点:当前线程类不嫩继承其他的类,因为java是单继承

1. 实现Runnable接口,重写run方法

优点:当前类可以多实现,还可以继承一个父类

           把线程对象和线程的逻辑代码分开

缺点:Runnable接口的子实现类只有一个run方法

           要使用其他的线程方法需要:

           Thread t=new Thread(Runnable接口的子实现对象);

           t.start();

1. 匿名内部类,重写run方法

优点:写法简单,编码量少

缺点:run的实现只有一次,且对象只有一个

 

线程的api:

-static Thread currentThread ();

         获取当前的线程对象

-long getId();

         获取当前线程的标识符

-String getName();

         获取线程的名字

-int getPriority();

         获取线程的优先级

         共有10级 1(低)-----------10(高)

-boolean isAlive();

         获取当前线程是否为活动状态

-boolean isDaemon();

         获取当前线程是否为守护线程

-boolean isInterrupted();

         获取线程是否中断

-static void sleep(long 毫秒数)

         让当前正在执行的线程休眠指定的毫秒数(暂停执行)

         此操作受操作系统计时器和调度程序的精度和准确度的影响

守护线程:当进程只剩下守护线程时,所有的守护线程强制终止

联合线程:

         void join();

                   此方法用于等待当期那线程结束

                   比如:

                   t1.join();//t1线程没有结束,当前线程不会结束(t1在其他线程内)

public class TestThreadJoinClass {

    /**

     * 1.创建线程t1,该线程要模拟图片的下载过程,

     * 该线程输出一个字符串"t1:已下载图片"+下载的百分比

     * 例如 :t1:已下载图片+10%

     * 2.创建线程t2,该线程输出"t2:等待图片下载"

     * 然后把t1线程作为t2线程的主线程,

     * 最后输出"t2:显示图片"

     * (此功能必须等待t1线程结束下载完毕才可以由t2线程显示图片

     * 3.启动t1线程和t2线程

     * @param args

     */

    public static void main(String[] args) {

        //1.创建线程t1

        Thread t1=new Thread(new Runnable() {

           

            @Override

            public void run() {

                System.out.println("t1:run begin");

                for(int i=0;i<20;i++){

                    System.out.println("t1:下载图片"+i+"%");

                    try {

                        Thread.sleep(500);

                    } catch (InterruptedException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                }

                System.out.println("t1:run end 图片下载完毕");

               

            }

        });

        t1.start();

        //创建一个线程t2

        Thread t2=new Thread(new Runnable() {

            @Override

            public void run() {

                System.out.println("t2:等待图片下载完毕begin");

                    try {

                        //t1线程没有结束,t2线程(当前线程)不会继续执行

                        //t1在谁里面谁等待

                        //t2线程处于线程阻塞block,挂起

                        //等待t1执行结束,t2(当前线程)才继续执行

                        t1.join();

                    } catch (InterruptedException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                System.out.println("t2:显示图片end");

                    }

        });

        t2.start();

    }

}

class MyThread extends Thread{

    @Override

    public void run() {

        int i=0;

        while(i<=100){

            System.out.println("t1:下载图片"+i+"%");

            try {

                Thread.sleep(500);

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

            i+=5;

        }

    }

}

线程的几个重要关键点:

1. 线程何时启动,即线程对象.start(),是有先后顺序的

有可能某个线程的启动要看他的主线程是否启动

1. run方法的执行顺序(run方法是并发执行的):靠的是线程对象.start()后何时能获取到CPU

2. 可能run并发执行着,需要注意线程之间的依存关系,当前线程是否执行完毕,是依赖于另一个线程是否执行完毕,run都执行,但是结束是有顺序的(联合线程,join方法)

 

synchronized关键字 同步 反义词asynchronized 异步

同步资源,同步锁

此关键字修饰在方法上

比如

         public synchronized void method(){

//代码块

}

当线程一代用method方法时,就会给method添加一个锁,如果方法不执行完毕,其他线程就不能执行此方法,线程排队等待

 

此关键字修饰在对象上

synchronized(某个对象){

         //变成同步代码块

}

         当线程一执行同步代码块,会给对象添加一个锁,如果代码块不执行完毕,其他线程就不能执行此代码块,线程排队等待

此关键字修饰在类上

         比如

         synchronized(类名.class){

//变成同步代码块

}

当线程一执行同步代码块时,会给类添加一个锁,如果代码块不执行完毕,其他线程不能执行此代码块,线程排队等待

 

线程池:把若干用户线程添加到线程池中,由线程池管理线程

为什么要使用线程:

1. 减少创建和销毁线程的次数,每个工作线程都能重复使用,利用,可以并发执行多任务

2. 可以根据系统的承受能力调整线程池中的工作线程的数目

防止因为消耗过多的内存使服务器宕机

         结论:java提供一些api方法用于更好的管理线程,让程序员主要用于写线程的逻辑

 

线程池的使用:

         有一个Executors的线程工具类,此类通过了若干的静态方法,这些静态方法用于生成线程池的对象

手动创建线程池对象:

1. Executors.newSingleThreadExecutor();

创建一个单线程的线程池,这个线程池只有一个线程在工作

单线程执行任务,如果这个唯一的线程因为一场结束,就会有一个新的线程来替代它,因此线程池保证所有的任务是按照任务的提交顺序进行

1. Executors.newFixedThreadPool();

创建固定大小的线程池,每次提交任务就创建一个线程,直到线程数量达到线程池的最大大小,线程池中的线程一旦达到线程池的最大容量,就会保持不变,如果某一个线程因为异常结束,就会向线程池中补充一个新的线程

1. Executors.newCacheedThreadPool();

创建一个可以缓冲的线程池,如果线程的数目超过了处理任务所需要的线程,那么就回收部分线程,当任务数增加时,每次线程池又可以智能的添加新的线程来处理任务,此线程池不会对线程池的大小做限制,线程池的大小完全依赖操作系统能够创建的最大大小

1. Executors.newScheduledThreadPool();

创建一个大小无限制的线程池,此线程池支持定时及周期性的执行任务的需求.