java 微信多线程推送_Java多线程详解

引言

随着计算机的配置越来越高，我们需要将进程进一步优化，细分为线程，充分提高图形化界面的多线程的开发。这就要求对线程的掌握很彻底。

那么话不多说，今天本帅将记录自己线程的学习。

程序，进程，线程的基本概念+并行与并发：程序：是为完成特定任务，用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。进程：是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程。-------生命周期线程：进程可进一步细化为线程，是一个程序内部的一条执行路径

即：线程《线程(一个程序可以有多个线程)

程序：静态的代码 进程：动态执行的程序

线程：进程中要同时干几件事时，每一件事的执行路径成为线程。并行：多个CPU同时执行多个任务，比如:多个人同时做不同的事并发：一个CPU(采用时间片)同时执行多个任务，比如秒杀平台，多个人做同件事

线程的相关API

//获取当前线程的名字

Thread.currentThread().getName()

1.start():1.启动当前线程2.调用线程中的run方法

2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中

3.currentThread():静态方法，返回执行当前代码的线程

4.getName():获取当前线程的名字

5.setName():设置当前线程的名字

6.yield():主动释放当前线程的执行权

7.join():在线程中插入执行另一个线程，该线程被阻塞，直到插入执行的线程完全执行完毕以后，该线程才继续执行下去

8.stop():过时方法。当执行此方法时，强制结束当前线程。

9.sleep(long millitime)：线程休眠一段时间

10.isAlive()：判断当前线程是否存活

判断是否是多线程

一条线程即为一条执行路径，即当能用一条路径画出来时即为一个线程

例：如下看似既执行了方法一，又执行了方法2，但是其实质就是主线程在执行方法2和方法1这一条路径，所以就是一个线程public class Sample{

public void method1(String str){

System.out.println(str);

}

public void method2(String str){

method1(str);

}

public static void main(String[] args){

Sample s = new Sample();

s.method2("hello");

}

}

线程的调度

调度策略：

时间片：线程的调度采用时间片轮转的方式

抢占式：高优先级的线程抢占CPU

Java的调度方法：

1.对于同优先级的线程组成先进先出队列(先到先服务)，使用时间片策略

2.对高优先级，使用优先调度的抢占式策略

线程的优先级

等级：

MAX_PRIORITY:10

MIN_PRIORITY:1

NORM_PRIORITY:5

方法：

getPriority():返回线程优先级

setPriority(int newPriority):改变线程的优先级

注意！：高优先级的线程要抢占低优先级的线程的cpu的执行权。但是仅是从概率上来说的，高优先级的线程更有可能被执行。并不意味着只有高优先级的线程执行完以后，低优先级的线程才执行。

多线程的创建方式

1. 方式1：继承于Thread类1.创建一个集成于Thread类的子类 (通过ctrl+o(override)输入run查找run方法)2.重写Thread类的run()方法3.创建Thread子类的对象4.通过此对象调用start()方法

start与run方法的区别：

start方法的作用：1.启动当前线程 2.调用当前线程的重写的run方法(在主线程中生成子线程，有两条线程)

调用start方法以后，一条路径代表一个线程，同时执行两线程时，因为时间片的轮换，所以执行过程随机分配，且一个线程对象只能调用一次start方法。

run方法的作用：在主线程中调用以后，直接在主线程一条线程中执行了该线程中run的方法。(调用线程中的run方法，只调用run方法，并不新开线程)

总结：我们不能通过run方法来新开一个线程，只能调用线程中重写的run方法(可以在线程中不断的调用run方法，但是不能开启子线程，即不能同时干几件事)，start是开启线程，再调用方法(即默认开启一次线程，调用一次run方法，可以同时执行几件事)

多线程例子(火车站多窗口卖票问题)package com.example.paoduantui.Thread;

import android.view.Window;

/**

*

* 创建三个窗口卖票，总票数为100张，使用继承自Thread方式

* 用静态变量保证三个线程的数据独一份

*

* 存在线程的安全问题，有待解决

*

* */

public class ThreadDemo extends Thread{

public static void main(String[] args){

window t1 = new window();

window t2 = new window();

window t3 = new window();

t1.setName("售票口1");

t2.setName("售票口2");

t3.setName("售票口3");

t1.start();

t2.start();

t3.start();

}

}

class window extends Thread{

private static int ticket = 100; //将其加载在类的静态区，所有线程共享该静态变量

@Override

public void run() {

while(true){

if(ticket>0){

// try {

// sleep(100);

// } catch (InterruptedException e) {

// e.printStackTrace();

// }

System.out.println(getName()+"当前售出第"+ticket+"张票");

ticket--;

}else{

break;

}

}

}

}

2. 方式2：实现Runable接口方式1.创建一个实现了Runable接口的类2.实现类去实现Runnable中的抽象方法：run()3.创建实现类的对象4.将此对象作为参数传递到Thread类中的构造器中，创建Thread类的对象5.通过Thread类的对象调用start()

具体操作，将一个类实现Runable接口，(插上接口一端)。

另外一端，通过实现类的对象与线程对象通过此Runable接口插上接口实现package com.example.paoduantui.Thread;

public class ThreadDemo01{

public static void main(String[] args){

window1 w = new window1();

//虽然有三个线程，但是只有一个窗口类实现的Runnable方法，由于三个线程共用一个window对象，所以自动共用100张票

Thread t1=new Thread(w);

Thread t2=new Thread(w);

Thread t3=new Thread(w);

t1.setName("窗口1");

t2.setName("窗口2");

t3.setName("窗口3");

t1.start();

t2.start();

t3.start();

}

}

class window1 implements Runnable{

private int ticket = 100;

@Override

public void run(){

while(true){

if(ticket>0){

// try {

// sleep(100);

// } catch (InterruptedException e) {

// e.printStackTrace();

// }

System.out.println(Thread.currentThread().getName()+"当前售出第"+ticket+"张票");

ticket--;

}else{

break;

}

}

}

}

比较创建线程的两种方式：

开发中，优先选择实现Runable接口的方式

原因1：实现的方式没有类的单继承性的局限性

2：实现的方式更适合用来处理多个线程有共享数据的情况

联系：Thread也是实现自Runable，两种方式都需要重写run()方法，将线程要执行的逻辑声明在run中

3.新增的两种创建多线程方式

1.实现callable接口方式：与使用runnable方式相比，callable功能更强大些：runnable重写的run方法不如callaalbe的call方法强大，call方法可以有返回值方法可以抛出异常支持泛型的返回值需要借助FutureTask类，比如获取返回结果package com.example.paoduantui.Thread;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

/**

*创建线程的方式三：实现callable接口。---JDK 5.0新增

*是否多线程？否，就一个线程

** 比runable多一个FutureTask类，用来接收call方法的返回值。

*适用于需要从线程中接收返回值的形式

** //callable实现新建线程的步骤：

*1.创建一个实现callable的实现类

*2.实现call方法，将此线程需要执行的操作声明在call()中

*3.创建callable实现类的对象

*4.将callable接口实现类的对象作为传递到FutureTask的构造器中，创建FutureTask的对象

*5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法启动(通过FutureTask的对象调用方法get获取线程中的call的返回值)

** */

//实现callable接口的call方法

class NumThread implements Callable{

private int sum=0;//

//可以抛出异常

@Override

public Object call() throws Exception {

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

if(i % 2 == 0){

System.out.println(Thread.currentThread().getName()+":"+i);

sum += i;

}

}

return sum;

}

}

public class ThreadNew{

public static void main(String[] args){

//new一个实现callable接口的对象

NumThread numThread = new NumThread();

//通过futureTask对象的get方法来接收futureTask的值

FutureTask futureTask = new FutureTask(numThread);

Thread t1 = new Thread(futureTask);

t1.setName("线程1");

t1.start();

try {

//get返回值即为FutureTask构造器参数callable实现类重写的call的返回值

Object sum = futureTask.get();

System.out.println(Thread.currentThread().getName()+":"+sum);

} catch (ExecutionException e) {

e.printStackTrace();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

使用线程池的方式：

背景：经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建好多个线程，放入线程池之，使用时直接获取，使用完放回池中。可以避免频繁创建销毁，实现重复利用。类似生活中的公共交通工具。(数据库连接池)

好处：提高响应速度(减少了创建新线程的时间)

降低资源消耗(重复利用线程池中线程，不需要每次都创建)

便于线程管理

corePoolSize:核心池的大小

maximumPoolSize:最大线程数

keepAliveTime：线程没有任务时最多保持多长时间后会终止

。。。。。。

JDK 5.0 起提供了线程池相关API：ExecutorService 和 Executors

ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor.

void execute(Runnable coommand):执行任务/命令，没有返回值，一般用来执行Runnable

Futuresubmit(Callable task):执行任务，有返回值，一般又来执行Callable

void shutdown()：关闭连接池。

Executors工具类，线程池的工厂类，用于创建并返回不同类型的线程池Executors.newCachedThreadPool()创建一个可根据需要创建新线程的线程池Executors.newFixedThreadPool(n)创建一个可重用固定线程数的线程池Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池Executors.newScheduledThreadPool(n)创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

线程池构造批量线程代码如下：package com.example.paoduantui.Thread;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

* 创建线程的方式四：使用线程池(批量使用线程)

*1.需要创建实现runnable或者callable接口方式的对象

* 2.创建executorservice线程池

* 3.将创建好的实现了runnable接口类的对象放入executorService对象的execute方法中执行。

* 4.关闭线程池

*

* */

class NumberThread implements Runnable{

@Override

public void run(){

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

if (i % 2 ==0 )

System.out.println(Thread.currentThread().getName()+":"+i);

}

}

}

class NumberThread1 implements Runnable{

@Override

public void run(){

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

if(i%2==1){

System.out.println(Thread.currentThread().getName()+":"+i);

}

}

}

}

public class ThreadPool{

public static void main(String[] args){

//创建固定线程个数为十个的线程池

ExecutorService executorService = Executors.newFixedThreadPool(10);

//new一个Runnable接口的对象

NumberThread number = new NumberThread();

NumberThread1 number1 = new NumberThread1();

//执行线程,最多十个

executorService.execute(number1);

executorService.execute(number);//适合适用于Runnable

//executorService.submit();//适合使用于Callable

//关闭线程池

executorService.shutdown();

}

}

目前两种方式要想调用新线程，都需要用到Thread中的start方法。

java virtual machine(JVM)：java虚拟机内存结构

程序(一段静态的代码)——————》加载到内存中——————》进程(加载到内存中的代码，动态的程序)

进程可细分为多个线程，一个线程代表一个程序内部的一条执行路径

每个线程有其独立的程序计数器(PC，指导着程序向下执行)与运行栈(本地变量等，本地方法等)