一、基本概念
1、什么是进程
进程是正在执行的程序,每一个进程都有一个执行顺序。当一个程序执行,操作系统将为为其分配资源。
2、什么是线程
线程是进程中的一个实体,是被系统独立调度和分派的基本单位。线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。JVM中,一个进至少有一个线程(不算垃圾回收线程)。
3、多线程存在的意义
(1)达到同时处理的效果,实际上是更好的抢夺CPU资源。
(2)一个线程可以为另一个线程服务,从操作系统角度而言,充分利用了CPU资源,用户角度而言,用户等待时间更少。
4、线程的创建方式
Java中,创建线程有两种方式
一种方法是将类声明为 Thread 的子类,并重写该子类的run方法,另一种方法是实现 Runnable 接口的类,并重写该子类的run方法。然后再调用线程实例的start()方法。调用start()方法时 ,JVM为我们做了两件事:启动线程,调用run()方法。
示例:创建线程的方式:声明为Thread的子类。
public class threadDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread thread = new MyThread();
thread.start();
for(int i = 0;i<1000;i++){
System.out.println("main---"+i);
}
}
}
class MyThread extends Thread{
public void run(){
for(int i= 0;i<1000;i++){
System.out.println("run()----"+i);
}
}
}
示例:实现Runanble接口
public class ThreadDemo1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread thread = new MyThread();
new Thread(thread).start();
for(int i = 0;i<1000;i++){
System.out.println("main()---"+i);
}
}
}
class MyThread implements Runnable{
public void run(){
for(int i =0;i<1000;i++){
System.out.println("run()----"+i);
}
}
}
结果可以看到main—和run—交替输出,并且每次结果都不同,说明结果具有随机性,主线程和子线程在“同时”运行时,每次获得的CPU调度具有随机性(在不改变线程优先级的情况下);
5、线程实例调用start()方法和run()方法的区别;
start:开启线程并执行该线程的run方法。
run:仅仅是对象的方法调用,而线程创建了,并没有运行。
6、线程生命周期
当new一个线程,实际上创建了一个线程,调用start方法后进入Runnable状态,即可以被调度运行状态,并没有真正开始运行,调度器可以将CPU分配给它,使线程进入Running状态,真正运行其中的程序代码。线程在运行过程中,有以下几个可能的去向:
(1)时间片轮转结束,这个线程又变为Runnable状态,等待处理机调度。
(2)处理机将时间片给了该线程,执行过程中没有遇到任何阻隔,也就是run()方法执行完毕。
(3)线程在执行过程中请求锁,却得不到,这时候它要进入lock pool中等待对象的锁,等到锁后又会进入Runnable状态,可以被调度运行。
(4)线程在执行过程中遇到wait()方法,它会被放入wait pool中等待,直到有notify()或interrupt()方法执行,它才会被唤醒或打断进入lock pool开始等待对象锁,等到锁后进入Runnable状态。
7、线程的的标识
自定义线程都有一个名称:Thread-编号,编号从0开始。
示例:
public class threadDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread thread = new MyThread();
MyThread thread1 = new MyThread();
thread.start();
thread1.start();
}
}
class MyThread extends Thread{
public void run(){
while(true){
System.out.println(this.getName());
}
}
}
可以看到Thread-0和Thread-1输出。
如何给线程命名
public class threadDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread thread = new MyThread("thread");
MyThread thread1 = new MyThread("thread1");
thread.start();
thread1.start();
}
}
class MyThread extends Thread{
MyThread(String s){
super(s);
}
public void run(){
while(true){
System.out.println(this.getName());
}
}
}
查看API文档,Thread里面有个构造方法Thread(String name),MyThread继承Thread,重写了构造方法。
给线程命名的第二种方式,thread对象调用setName(),也能达到同样的效果。
示例:
public class threadDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread thread = new MyThread();
thread.setName("thread");
MyThread thread1 = new MyThread();
thread1.setName("thread1");
thread.start();
thread1.start();
}
}
class MyThread extends Thread{
public void run(){
while(true){
System.out.println(this.getName());
}
}
}
看一个售票示例:有四个窗口同时售票,当然不能售出相同的票,这里可以在tickets类中定义一个静态的成员变量,被子线程所共享。售出的票将不会相同。
public class TicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ticket t1 = new ticket();
ticket t2 = new ticket();
ticket t3 = new ticket();
ticket t4 = new ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class ticket extends Thread{
private static int tickets = 100;
boolean more = true;
public void run() {
while (more) {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName()
+ "...sale:" + tickets--);
}else {
more = false;
}
}
}
}
再来看用实现Runnable接口子类来实现多线程的例子。定义一个Runnable接口的子类对象。启动四个线程来同时调用子类的run方法,同样能够达到售票效果。不然看出,创建线程,关联实现Runnable接口的子类,并调用其run方法,能够实现资源的共享。
public class Runnabletest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
tickets t = new tickets();
Thread thread1 = new Thread(t);
Thread thread2 = new Thread(t);
Thread thread3 = new Thread(t);
Thread thread4 = new Thread(t);
thread1.start();
thread2.start();
thread3.start();
thread4.start();
}
}
class tickets implements Runnable{
private int tickets = 100;
boolean more = true;
public void run() {
while (more) {
if (tickets > 0) {
System.out.println(Thread.currentThread().getName()
+ "...sale:" + tickets--);
}else {
more = false;
}
}
}
}
实现Runnable接口启动线程的好处:1、避免但继承的局限性(Java只支持单继承继承)2、能做到资源的共享。
两种方式的区别:
线程代码存放的位置不同:继承Thread :代码存放在Thread子类的run方法中;实现Runnable接口:代码存放在接口子类的run方法中。
二、Java多线程的安全问题
1、同步代码块解决java多线程中对共享代码块的访问(关键字synchronized)
上述的卖票程序会出现一个问题:当tickets为1时,thread0 的if (tickets > 0)判断结束后,下一个 thread执行,将ticket–.则thread0会卖出ticket为0的票。解决办法:在对共享数据操时,不可以被其他线程打断。下面的同步代码块解决了这一问题,不会出现卖负数票的情况。弊端:多了一步锁的判断消耗了资源。
示例:
public class TicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ticket t1 = new ticket();
ticket t2 = new ticket();
ticket t3 = new ticket();
ticket t4 = new ticket();
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class ticket extends Thread{
private static int tickets = 100;
boolean more = true;
public void run() {
while (more) {
synchronized (new Object()) {
if (tickets > 0) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "...sale:" + tickets--);
} else {
more = false;
}
}
}
}
}
2、同步函数(用synchronized修饰的函数)
示例:
public class SyschronizedTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
class Bank {
private int sum;
public void add(int n) {
try {
Thread.sleep(40);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sum += n;
System.out.println("sum=" + sum);
}
}
class Cus implements Runnable {
private Bank bank = new Bank();
public void run() {
for (int i = 0; i < 3; i++) {
bank.add(100);
}
}
}
以上程序在运行时会出现一个问题:Thread-0调用add方法, 执行完sum += n,假设此时sum值为100,之后,中断,Thread-1执行sum += n,此时sum值为200,Thread-0继续执行,打印结果为sum=200,出现了错误。为此我们加入了synchronized关键字来修饰add()方法,避免这一状况发生。
如下示例所示:
public class SyschronizedTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
class Bank {
private int sum;
public synchronized void add(int n) {
try {
Thread.sleep(40);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sum += n;
System.out.println("sum=" + sum);
}
}
class Cus implements Runnable {
private Bank bank = new Bank();
public void run() {
for (int i = 0; i < 3; i++) {
bank.add(100);
}
}
}
3、同步函数的锁是this指针。
验证一下:创建两个线程一个线程执行run方法中的同步代码块,另一个线程执行run方法中的同步函数。
示例:
public class TicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ticket t1 = new ticket();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t1);
thread1.start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t1.flag = false;
thread2.start();
}
}
class ticket implements Runnable{
private int tickets = 100;
boolean more = true;
boolean flag = true;
public void run() {
if (flag) {
while (more) {
synchronized (this) {
if (tickets > 0) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "...sale:" + tickets--);
} else {
more = false;
}
}
}
}else{
show();
}
}
private synchronized void show(){
while (more) {
if (tickets > 0) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "...sale:" + tickets--);
} else {
more = false;
}
}
}
}
将同步代码块中的锁换成this后,执行结果正常,由此可以说明:同步函数中使用的锁是this.
4、stactic修饰的同步函数的锁是该方法所在类的字节码文件对象。
下面来验证一下,将程序稍作修改
public class TicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ticket t1 = new ticket();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t1);
thread1.start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t1.flag = false;
thread2.start();
}
}
class ticket implements Runnable{
private static int tickets = 100;
static boolean more = true;
boolean flag = true;
public void run() {
if (flag) {
while (more) {
synchronized (this) {
if (tickets > 0) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "...sale:" + tickets--);
} else {
more = false;
}
}
}
}else{
show();
}
}
private static synchronized void show(){
while (more) {
if (tickets > 0) {
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "...sale:" + tickets--);
} else {
more = false;
}
}
}
}
结果:
.................
Thread-0...sale:3
Thread-1...sale:2
Thread-0...sale:1
Thread-1...sale:0
出现了卖0票的情况,显然static 修饰的同步函数锁不是this,将this改成ticket.class后,程序正常,由此可以说名stactic修饰的同步函数的锁是该方法所在类的字节码文件对象。