1.线程、进程
1.1 概念
进程：引入：为了程序能够并发执行，且为了对并发执行的程序加以描述和控制，引入了进程的概念。
（1）进程是程序的一次执行。
（2）进程是一个程序及其数据在处理机上顺序执行时所发生的活动。
（3）进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。
（4）进程是作为能够拥有资源和独立运行的基本单位。
线程: 引入：在操作系统中引入线程，是为了减少程序并发执行时锁付出的空间开销，使OS具有更好的并发性。1.2
1.2 线程与进程进行比较
线程具有许多传统进程所具有的特征，所以又称为轻量级进程或进程元，相应的把进程称为重量级的进程，传统进程相当于只有一个线程的任务，在引入了新城的操作系统中，通常一个进程都拥有若干个线程，至少也有一个线程。
相同点：
（1）调度：
（2）并发性：在引入了线程的操作系统中，进程之间或一个线程中的多个线程之间都可以并发执行。
（3）拥有资源：不论是传统的操作系统还是引入了线程的操作系统，进程都可以拥有资源，是系统中拥有资源的有个基本单位。
（4）系统开销：在某些操作系统中，线程的切换、同步和通信都无需操作系统内核的干预。
不同点：
（1）调度：在传统操作系统中，进程是拥有资源的基本和独立调度、分派的基本单位，在引入了线程的操作系统中，线程是调度和分派的基本单位，而进程是拥有资源的基本单位。
（2）并发性：
（3）拥有资源：进程拥有资源，线程自己不拥有资源（也有一点必不可少的资源）。但可以吧访问其他隶属进程的资源。
（4）系统开销：
a.在创建或撤销进程的时候，系统都要为之创建和回收进程控制块，分配或回收资源。如内存空间和I/O设备，系统开销明显大于线程创建或撤销时的开销。
b.在进程切换时，涉及到当前进程CPU环境的保存及新被调度运行进程的CPU环境的设置，而线程的切换则仅需要保存和设置少量寄存器内容，不涉及存储器管理方面的操作，所以，进程的代价远高于线程。
c.一个进程的多个线程具有相同的地址空间，在同步和通信的实现方面线程也比进程容易。
（5）进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
（6）进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮。
（7）每个独立的线程都有一个程序运行的入口，顺序执行序列和程序的入口，但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
1.3 线程的生命周期
1.3.1.线程处于就绪状态有以下几种方法
（1）调用sleep（）方法
（2）调用wait（）方法
（3）等待输入/输出完成
1.3.2.当线程处于就绪状态后，可以用以下几种方法使线程进入运行状态：
（1）线程调用notify（）方法
（2）线程调用notifyAll（）方法
（3）线程调用interrupt（）方法
（4） 线程的休眠时间结束
（5）输入/输出结束
线程生命周期状态图：
2.线程的调度与控制
2.1 线程优先级
java虚拟机主要负责则线程的调度，获取CPU的使用权，目前有两种调度模型：分时调度模型和抢占调度模型;java使用抢占调度模型。
分时调度模型：所有线程轮流使用CPU的使用权，平均分配给每个线程占用CPU的时间片。
抢占调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么随机选择一个，优先极高的线程获得的CPU时间片相对多些。
例：
/*
线程优先级高的获取的时间片相对高
*/
class Threadtest04
{
public static void main(String[] args)
{
//线程优先级
System.out.println(Thread.MAX_PRIORITY); //10 优先级最高
System.out.println(Thread.MIN_PRIORITY); //1 优先级最低
System.out.println(Thread.NORM_PRIORITY); //5 默认优先级
Thread t1 = new P();
t1.setName("t1"); Thread t2 = new P();
t2.setName("t2"); System.out.println(t1.getPriority()); //默认优先级为5
System.out.println(t2.getPriority()); //默认优先级为5
//设置优先级
t1.setPriority(4);
t2.setPriority(9); System.out.println(t1.getPriority()); //默认优先级为5
System.out.println(t2.getPriority()); //默认优先级为5
//启动线程
t1.start();
t2.start();
}
} class P extends Thread
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println(Thread.currentThread().getName()+"..."+i);
}
}
}
/*
运行结果：
10
1
5
5
5
4
9
t1...0
t2...0
t1...1
t2...1
t1...2
t2...2
t1...3
t2...3
t1...4
t2...4
t1...5
t2...5
t1...6
t2...6
t1...7
t2...7
t1...8
t2...8
t1...9
t2...9
请按任意键继续. . . */
2.2 sleep方法
sleep和wait的区别：
（1）所属类不同
Thread.sleep() ； Object.wait()
（2）对于线程已经占有资源的处理
sleep在休息的时候，不释放资源 ； wait在等待的时候释放自己占用的资源
例：
/*
1.thread.sleep（毫秒）
2.sleep方法是一个静态方法
3.该方法作用：阻塞当前线程，将CPU让给其他线程
*/
class Threadtest05
{
public static void main(String[] args) throws InterruptedException
{
Thread t1 = new P();
t1.setName("t1");
t1.start();
Thread.sleep(5000);
//t1.interrupt();打断线程的睡眠
for(int i = 0;i<10;i++)
{
System.out.println(Thread.currentThread().getName()+".."+i);
Thread.sleep(500);//阻塞主线程0.5秒
}
}
} class P extends Thread
{
//被重写的方法不能抛出异常，在run方法的声明为置上不能呢使用Throws，
public void run()
{
for(int i = 0;i<10;i++)
{ try{
Thread.sleep(1000);//让当前线程阻塞1s
}catch(InterruptedException e)
{
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+".."+i);
}
}
}
/*
运行结果：
main..0
t1..0
main..1
t1..1
main..2
main..3
main..4
t1..2
main..5
t1..3
main..6
main..7
t1..4
main..8
main..9
t1..5
t1..6
t1..7
t1..8
t1..9
请按任意键继续. . . */
2.3 yield方法
使用yield方法，与sleep方法类似，不能由用户指定暂停多长时间，并且yield方法只能让同优先级的线程由执行机会,让位时间不固定。静态方法。
2.4 Join方法
合并线程
3.创建线程的三种方法
Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。Java可以用三种方式来创建线程，如下所示：
（1）继承Thread类创建线程
（2）实现Runnable接口创建线程
（3）使用Callable和Future创建线程
3.1.概念及特点
（1）.概念
进程：计算机运行的应用程序。（多进程作用：提高CPU的使用率，不提高速度）；
线程；一个进程中的执行场景，一个进程可以包多个线程。（多线程作用：提高应用程序的使用率，不提高速度）。
（2）.内存特点
进程和进程之间的内存是独立的；
线程和线程共享“堆内存的方法区内存”，栈内存是独立的，一个线程一个栈。
（3）.java程序的运行原理
Java命令启动Java虚拟机，启动JVM，等同于启动了一个应用程序，表示启动了一个进程，该进程会自动启动一个“主线程”，然后主线程去调用某个类的main方法，所 以main方法运行在主线程中。
3.2 线程的创建和启动
3.2.1 实现多线程的第一种方式
Thread类在包java.lang中，从这个类中实例化的对象代表线程，启动一个新线程需要建立Thread实例，Thread类中常用的两个构造方法如下：
（1）public Thread（String threadName）
（2）public Thread（）
其中第一个构造方法是创建一个名称为threadName的线程对象
创建一个新的线程的语法如下：
public class ThreadTest extends Thread{}完成线程真正功能的代码方法类run（）方法中，当一个类继承Thread类后，就可以在该类中覆盖run方法，将实现该线程功能的代码写入run（）方法中国，然后调用Thread类中的start（）方法执行线程，即调用run()方法.
Thread对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run（）方法中。当执行一个线程程序时，就自动产生一个线程，主方法是在这个线程上运次的，当不再启动其他线程时，该程序就为单线程程序。
以下是一个Thread类的实例：
/**
* 类ThreadTest继承继承Thread雷诺方法创建线程
* @author z
*
*/
public class ThreadTest extends Thread {
private int count = 10;
public void run(){
while(true){
System.out.println(count+"");
if(--count == 0){
return;
}
}
}
public static void main(String[] args){
new ThreadTest().start(); }
}
运行结果：10 9 8 7 6 5 4 3 2 1
分析：
在上例中，继承了Thread类，然后覆盖了run（）方法，通常在run（）方法中使用无限循环的形式，使得线程一直运行下去，所以要指定一跳出循环的条件，本例使用变量count递减为0的方法跳出循环条件。
在main()方发中，使线程执行需要调用Thread类中的start（）方法，start（）方法调用被覆盖的run（）方法，如果不调用start（）方法，线程永远不会启动，在主方法没有调用stsrt（）方法之前，Thread（）对象只是一个实例，而不是一个正真的线程。
再举一个例子：
第一步: 继承Java.lang.Thread
第二步；重写run方法
例：
class Threadtest01
{
public static void main(String[] args) //main方法在主线程
{
//1.创建线程
Thread t = new p();
//2.启动线程
t.start(); /*启动t线程，执行后，t线程瞬间结束，JVM再分配一个新的栈给t线程
run方法不需要手动调用，系统线程启动之后自动调用run方法。*/ for(int i=0;i<100;i++) //在主线程中运行
{
System.out.println("main....."+i);
}
}
}
/*
在多线程中，main方法结束后只是主线程踪没有方法栈帧了，但
其他线程中或者其他栈中还有栈帧，main方法结束，程序可能还在运行
*/ //3.定义一个线程
class p extends Thread
{
//重写run方法
public void run ()
{
for(int i=0;i<100;i++)
{
System.out.println("run...."+i);
}
}
}
/*
运行部分结果如下：
main.....0
main.....1
main.....2
run....0
main.....3
run....1
main.....4
run....2
main.....5
run....3
main.....6
run....4
main.....7
run....5
main.....8
run....6
*/
上述代码的图解如下：
3.3.2 实现多线程的第二种方式:
Runnable接口的说用是使线程不仅可以继承Thread类实现，还可以继承其他类(比如：JFrame)。
此接口具有两个构造方法:
(1)public Thread(Runnable r)
(2)public Thread(Runnable r,String name).
这两个构造方法的参数中都存在Runnable实例，使用构造方法就可以将Runnable实例与Thread实例相关联。
使用Runnable的步骤如下：
（1）建立Runnable对象
（2）使用参数为Runnable对象的构造方法创建Thread实例
（3）调用start（）方法。
例：在项目中创建SwingAndThread类，该类继承了JFrame类，实现图标移动的功能，其中使用了Swing与线程相结合的技术：
import java.awt.*;
import java.net.*; import javax.swing.*; public class SwingAndThread extends JFrame {
/**
*
*/
private static final long serialVersionUID = 1L;
private JLabel jl = new JLabel(); // 声明JLabel对象
private static Thread t; // 声明线程对象
private int count = 0; // 声明计数变量
private Container container = getContentPane(); // 声明容器 public SwingAndThread() {
setBounds(300, 200, 250, 100); // 绝对定位窗体大小与位置
container.setLayout(null); // 使窗体不使用任何布局管理器
URL url = SwingAndThread.class.getResource("/1.gif"); // 获取图片的URL
Icon icon = new ImageIcon(url); // 实例化一个Icon
jl.setIcon(icon); // 将图标放置在标签中
// 设置图片在标签的最左方
jl.setHorizontalAlignment(SwingConstants.LEFT);
jl.setBounds(10, 10, 200, 50); // 设置标签的位置与大小
jl.setOpaque(true);
t = new Thread(new Runnable() { // 定义匿名内部类，该类实现Runnable接口
public void run() { // 重写run()方法
while (count <= 200) { // 设置循环条件
// 将标签的横坐标用变量表示
jl.setBounds(count, 10, 200, 50);
try {
Thread.sleep(1000); // 使线程休眠1000毫秒
} catch (Exception e) {
e.printStackTrace();
}
count += 4; // 使横坐标每次增加4
if (count == 200) {
// 当图标到达标签的最右边，使其回到标签最左边
count = 10;
}
}
}
});
t.start(); // 启动线程
container.add(jl); // 将标签添加到容器中
setVisible(true); // 使窗体可视
// 设置窗体的关闭方式
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
} public static void main(String[] args) {
new SwingAndThread(); // 实例化一个SwingAndThread对象
}
}
运行结果：
再举一个例子：
第一步：写一个实现类java,lang.Runnable;接口
第二步：实现run方法
例：
package test; class Main
{
public static void main(String[] args)
{
//创建线程
Thread t = new Thread(new p());
//启动线程
t.start();
for(int i = 0;i<100;i++)
System.out.println("mian..."+i); }
}
//优先，一个类实现接口之外保留了类的继承
class p implements Runnable
{
public void run()
{
for(int i = 0;i<100;i++)
System.out.println("run..."+i);
}
}
/*
* 部分运行结果：
* run...8
mian...10
run...9
mian...11
run...10
mian...12
run...11
mian...13
run...12
*/
4.线程的同步（加锁）
4.1 基本概念及特点
（1）概念：
a.线程同步，是指某一个时刻，只允许一个线程访问共享资源，线程同步实际上是对对象加锁，如果对象中的方法都是同步方法，那么某一时刻只能执 行一个方法，采用线程同步解决以上问题; 为了数据安全，尽管应用程序的使用效率降低，但是为了数据安全，必须加入线程同步机制，线程同步机制使程序等同于单线程。
b.异步编程模型：多个线程分别执行，各线程互不影响。
c.同步编程模型：多个线程执行只有一个线程执行结束才能执行另一个线程。（作用：达到数据安全）
（2）使用线程同步机制的条件：
a：必须是多线程环境
b:多线程环境共享一个数据
c:共享的数据涉及到数据的修改
4.2 举例
例1：(对象锁，方法一，控制精确，常用)
/*
模拟银行取款系统：对于同一个账号，用两个线程同时对其取款。
*/
class Threadtest06
{
public static void main(String[] args)
{
//创建公共账号
Account act = new Account("账号sss",10000);
//创建两个线程对同一个账户取款
Thread t1 = new Thread(new P(act));
Thread t2 = new Thread(new P(act));
t1.start();
t2.start();
}
}
//取款线程
class P implements Runnable
{
//账户
Account act;
P(Account act)
{
this.act = act;
}
public void run()
{
act.withdraw(2000);
System.out.println("取款成功，余额为："+act.getBalance());
} }
//账户
class Account
{
private String action;
private double balance;
public Account(){}
public Account(String action,double balance){
this.action = action;
this.balance = balance;
}
public void setAction(String action)
{
this.action = action;
} public void setBalance(double balance)
{
this.balance = balance;
}
public String getAction(String action)
{
return action;
}
public double getBalance()
{
return balance;
}
public void withdraw(double money)
{
synchronized(this){ //this表示共享对象
double after = balance - money;
try{
Thread.sleep(1000);
}catch(Exception e){}
this.setBalance(after);
}
}
} /*
运行结果：
取款成功，余额为：8000.0
取款成功，余额为：6000.0
请按任意键继续. . . */
上例原理： t1线程执行到synchronized关键字处，就会去找this对象锁，如果找到this对象锁，就回进入同步语句块中执行，当同步语句块中的代码执行结束后，
t1线程归还this对象锁。在t1线程执行同步语句块的过程中，如果t2线程也过来执行此代码，也遇到synchronized关键字，所以也去找this对象锁，但是
该对象锁被t1线程持有，只能等待this对象的归还。
例2；synchronized关键字添加到成员方法上，线程拿到的扔是this的对象锁（对象锁，方法二，执行效率低）
/*
模拟银行取款系统：对于同一个账号，用两个线程同时对其取款。
*/
class Threadtest06
{
public static void main(String[] args)
{
//创建公共账号
Account act = new Account("账号sss",10000);
//创建两个线程对同一个账户取款
Thread t1 = new Thread(new P(act));
Thread t2 = new Thread(new P(act));
t1.start();
t2.start();
}
}
//取款线程
class P implements Runnable
{
//账户
Account act;
P(Account act)
{
this.act = act;
}
public void run()
{
act.withdraw(2000);
System.out.println("取款成功，余额为："+act.getBalance());
} }
//账户
class Account
{
private String action;
private double balance;
public Account(){}
public Account(String action,double balance){
this.action = action;
this.balance = balance;
}
public void setAction(String action)
{
this.action = action;
} public void setBalance(double balance)
{
this.balance = balance;
}
public String getAction(String action)
{
return action;
}
public double getBalance()
{
return balance;
}
public synchronized void withdraw(double money)
{ double after = balance - money;
try{
Thread.sleep(1000);
}catch(Exception e){}
this.setBalance(after); }
} /*
运行结果：
取款成功，余额为：8000.0
取款成功，余额为：6000.0
请按任意键继续. . . */
（另：StirngBuffer Vector Hashtable 是线程安全的 ）
5.死锁
例：
/*
死锁
*/
class DeadLook
{
public static void main(String[] args)
{
Object o1 = new Object();
Object o2 = new Object(); Thread t1 = new Thread(new T1(o1,o2));
Thread t2 = new Thread(new T2(o1,o2));
t1.start();
t2.start();
}
} class T1 implements Runnable
{
Object o1;
Object o2;
T1(Object o1,Object o2)
{
this.o1 = o1;
this.o2 = o2;
}
public void run()
{
synchronized(o1)
{
try{Thread.sleep(1000);}catch(Exception e){}
synchronized(o2)
{
System.out.println("t1");
}
}
}
}
class T2 implements Runnable
{
Object o1;
Object o2;
T2(Object o1,Object o2)
{
this.o1 = o1;
this.o2 = o2;
}
public void run()
{
synchronized(o2)
{
try{Thread.sleep(1000);}catch(Exception e){}
synchronized(o1)
{
System.out.println("t2");
}
}
}
}
6.守护线程
从线程的分类上可以分为：用户线程和守护线程，所有的用户线程结束生命周期，只有一个用户线程存在，那么守护线程就不会结束，Java中的垃圾回收器就
是一个守护线程，只有应用程序中所有的线程结束，它才会结束。
例：
/*
守护线程：
所有的用户线程结束，守护线程才会结束，守护线程是一个无限循环执行的。
*/
class Threadtest08
{
public static void main(String[] args) throws Exception
{
Thread t1 = new P();
t1.setName("t1");
t1.setDaemon(true);//将用户线程修改为守护线程
t1.start();
//主线程
for(int i = 0;i < 10; i++)
{
System.out.println(Thread.currentThread().getName()+".."+i);
Thread.sleep(1000);
}
}
} class P extends Thread
{
public void run()
{
int i = 0;
while(true)
{
i++;
System.out.println(Thread.currentThread().getName()+".."+i);
try{Thread.sleep(1000);}catch(Exception e){}
}
}
}
/*
运行结果：
main..0
t1..1
t1..2
main..1
t1..3
main..2
main..3
t1..4
main..4
t1..5
main..5
t1..6
main..6
t1..7
main..7
t1..8
main..8
t1..9
main..9
t1..10
请按任意键继续. . . */
7.Timer定时器
作用：每隔一段固定的时间执行一段代码
例：
/*
定时器
*/
import java.text.*;
import java.util.*;
class Timertest
{
public static void main(String[] args) throws Exception
{
//创建定时器
Timer t = new Timer();
//指定定时任务
t.schedule(new LogTimerTask(),new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").parse("2017-04-21 11:42:00 000"),10*1000); }
}
//指定任务
class LogTimerTask extends TimerTask
{
public void run()
{
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()));
}
}
8.线程池
参考资料 http://www.importnew.com/19011.html
http://lavasoft.blog.51cto.com/62575/27069/
https://mp.weixin.qq.com/s?__biz=MzI1NDQ3MjQxNA==&mid=2247484346&idx=1&sn=f065ebd404771a90988bb097ea4e26dd&chksm=e9c5fa0bdeb2731d12b838372fc8aa97890dd2e3379d1a486df7cf795f8a1538c1ae974a13e7&mpshare=1&scene=23&srcid=1022Iecc2i96j9Drfxgzd274#rd