java线程的总结

线程

Java中的进程、线程和多线程

一、进程：进程就是一个正在执行的程序。

二、线程：线程是进程执行的一条线索或路径。进程中至少有一个线程存在。

三、多线程：顾名思义，一个进程中的多个线程。

线程的开始：当要运行一个程序时，JVM首先会找到main函数，然后从main函数开始执行(也就是说，程序是从main函数开始运行的)，

此时，程序就成为一个进程，既然是进程肯定有线程的存在。此时的线程就是主线程，主线程会向下顺序执行代码。

如果程序中存在一个庞大的循环语句，主程序就会一直在这里运行，直到循环语句结束，下面的代码才能被执行到。

这可能要花费较长的时间，影响了程序运行的效率。所以，为了提高程序的效率，就引入了多线程。由主线程开辟另一个或多个线程，

让这些线程都去执行代码。

线程线程是一个程序内部的控制流

java的线程是通过java.long.Thread类实现的，VM启动时会有一个主方法public static void main(){}的线程

1 可以通过Thread的实例来创建一个新的线程，必须通过start来开始一个线程，每个线程都是通过特定的Thread对象来调用run方法来完成其操作的，方法run（）称为线程体。

类直接继承Thread也可以形成线程，但是这样该类就只能继承一个类

而实现接口的话，可以实现多个接口，从而更加灵活。

2 实现Runnable接口，复写run方法。

用Thread来new一个线程对象，并将Runnable的子类对象传入Thread的构造方法中。我们用代码来模拟铁路售票系统，实现通过四个售票点发售某日某次列车的100张车票，一个售票点用一个线程表示。我们首先这样编写这个程序：

1public class ThreadDome1{

2public static void main(String[] args){

3ThreadTest t = new ThreadTest();

4t.start();

5t.start();

6t.start();

7t.start();

8}

9}

10class ThreadTest extends Thread{

11private int ticket = 100;

12public void run(){

13while(true){

14if(ticket > 0){

15System.out.println(Thread.currentThread().getName() +

16"is saling ticket" + ticket--);

17}else{

18break;

19}

20}

21}

22}

上面的代码中，我们用ThreadT est类模拟售票处的售票过程，run方法中的每一次循环都将总票数减1，模拟卖出一张车票，同时该车票号打印出来，直接剩余的票数到零为止。在ThreadDemo1类的main方法中，我们创建了一个线程对象，并重复启动四次，希望通过这种方式产生四个线程。从运行的结果来看我们发现其实只有一个线程在运行，这个结果告诉我们：一个线程对象只能启动一个线程，无论你调用多少遍start()方法，结果只有一个线程。

我们接着修改ThreadDemo1，在main方法中创建四个Thread对象：

1public class ThreadDemo1{

2public static void main(String[] args){

3new ThreadTest().start();

4new ThreadTest().start();

5new ThreadTest().start();

6new ThreadTest().start();

7}

8}

9class ThreadTest extends Thread{

10private int ticket = 100;

11public void run(){

12while(true){

13if(ticket > 0){

14System.out.println(Thread.currentThread().getName() +

15" is saling ticket" + ticket--);

16}else{

17break;

18}

19}

20}

21}

这下达到目的了吗?

从结果上看每个票号都被打印了四次，即四个线程各自卖各自的100张票，而不去卖共同的100张票。这种情况是怎么造成的呢?我们需要的是，多个线程去处理同一个资源，一个资源只能对应一个对象，在上面的程序中，我们创建了四个ThreadTest对象，就等于创建了四个资源，每个资源都有100张票，每个线程都在独自处理各自的资源。

经过这些实验和分析，可以总结出，要实现这个铁路售票程序，我们只能创建一个资源对象，但要创建多个线程去处理同一个资源对象，并且每个线程上所运行的是相同的程序代码。在回顾一下使用接口编写多线程的过程。

1public class ThreadDemo1{

2public static void main(String[] args){

3ThreadTest t = new ThreadTest();

4new Thread(t).start();

5new Thread(t).start();

6new Thread(t).start();

7new Thread(t).start();

8}

9}

10class ThreadTest implements Runnable{

11private int tickets = 100;

12public void run(){

13while(true){

14if(tickets > 0){

15System.out.println(Thread.currentThread().getName() +

16" is saling ticket " + tickets--);

17}

18}

19}

20}

上面的程序中，创建了四个线程，每个线程调用的是同一个ThreadT est对象中的run()方法，访问的是同一个对象中的变量(tickets)的实例，这个程序满足了我们的需求。在Windows 上可以启动多个记事本程序一样，也就是多个进程使用同一个记事本程序代码。

实现Runnable接口相对于继承Thread类来说，有如下显著的好处：

(1)适合多个相同程序代码的线程去处理同一资源的情况，把虚拟CPU(线程)同程序的代码，数据有效的分离，较好地体现了面向对象的设计思想。

(2)可以避免由于Java的单继承特性带来的局限。我们经常碰到这样一种情况，即当我们要将已经继承了某一个类的子类放入多线程中，由于一个类不能同时有两个父类，所以不能用继承Thread类的方式，那么，这个类就只能采用实现Runnable接口的方式了。

(3)有利于程序的健壮性，代码能够被多个线程共享，代码与数据是独立的。当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码。多个线程操作相同的数据，与它们的代码无关。当共享访问相同的对象时，即它们共享相同的数据。当线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。

线程的状态与生命周期

1. 新建状态当创建一个Thread类或子类的对象时，该线程称为新建的线程

2. 就绪：线程创建后，处于就绪状态，等待start()方法被调用

3. 运行：线程开始执行进入运行状态

4. 睡眠：线程的执行可以通过调用sleep()方法来暂时中止

5. 等待：如果调用了wait()方法，线程将处于等待状态。用于两个或多个线程并发运行时

6. 挂起(Suspended)：在临时停止或中断线程的执行时，线程就处于挂起状态

7. 阻塞（Blocked）：在线程等待一个事件时，例如输入输出操作，就称其处于阻塞状态

8. 死亡：在run()方法已完成执行或stop()方法被调用后，线程处于死亡状态

优先级

设置线程的优先级，用setPriority（）方法，该方法也是thread类成员。它的通常形式为：final void setPrority（int level）

这里level指定了对所调用的线程的新的优先权的设置。level的值必须在MIN_PRIORITY到MAX_PRIORITY范围内。通常，它们的值分别是1和10.要返回一个线程为默认的优先级，指定NORM_PRIORITY，通常值为5.这些优先级在Thread中都被定义为final型变量。

通过调用thread类的getPriority（）方法可以获得当前的优先级设置。方法如下：final int getPriority（）

如果t1的优先级比t2高，并不是说t2不执行，而是t1执行时间多点，t2执行时间少

正常停止一个线程的方法，不是调用interrupt ,stop,而是定义一个变量，bollean f=true; class M yThread extends Thread{

public void run(){

bollean f=true;

while(true){

System.out.println("1");

try{

sleep(1000);

}catch(InterruptedException e){

return;

}

多线程的安全问题

什么时候会出现线程安全问题？

满足3个条件时，会出现：

1.存在多个线程

2.多个线程共享数据（共享数据一般是成员变量，局部变量不是）。

3.操作共享数据的语句至少要有两条。

出现安全问题的原因：多个线程执行共享数据的代码块时，其中的一个线程还没有执行完代码块，另一个线程就开始执行代码块，这会造成共享数据的错误。从而出现安全问题。

多线程安全问题的解决：同步。因为同步可以保证多线程代码只能被持有锁的线程运行，其

它线程不能运行。

任意时刻，一个锁只能被一个线程拥有。（持有锁的线程会在执行完多线程代码时

释放锁，这样锁就能被其它线程拥有。）

1.同步代码块；将要同步的代码放synchronized中，并加锁。

synchronized(对象)//只要是个对象就行，这个对象就是锁

{要被同步的代码}

2.同步函数：synchronized能将代码封装并同步，函数只能将代码封装，所以用synchronized 修饰函数，让函数既能封装又能同步。

同步函数也有锁。非静态同步函数的锁是this，同步函数所属对象的引用；静态同步函数的锁是:类名.class,函数所属类的字节码文件对象。

需注意的是：1.不需要同步的代码不要放入同步函数中。2.synchronized

放在函数返回值类型前

public synchronized void show()

{ 要被同步}

找到要被同步的代码的方法：

1.先找到多线程所有要运行的代码（可能是一个run方法被多个线程使用同，也可能是一个run方法只被其中的一个线程使用）；

2.多线程的共享数据(一般成员变量都是)；

3.多线程要运行的代码中操作共享数据的代码就是要被同步的代码。

注意：有时使用了同步仍然不成功，出现这种现象的原因可能是：需要被同步的代码可能放在程序的不同位置，有的代码要用到同步代码块，有的要用同步函数

那么怎么才能使同步成功？

1.首先判断要被同步的代码是否正确，确定所有要被同步的代码都被同步了。

2.同步代码块和同步函数中的锁是同一个锁，即必须是多个线程使用同一个锁

线程同步的问题

1.方法声明时使用，放在范围操作符(public等)之后，返回类型声明(void等)之前。即一次只能有一个线程进入该方法，其他线程要想在此时调用该方法，只能排队等候，当前线程（就是在synchronized方法内部的线程）执行完该方法后，别的线程才能进入。锁定后别的线程不能调用该方法B，但是其他线程可以调用别的未锁定的方法A，访问方法A就有可以改变方法B中的变量。解决方法时，将两个方法全部加锁.

针对某变量，想要同步，涉及改该变量的方法都要加锁，而读该变量的方法不需要加锁

public class T T implements runnable{

int m=100;

public synchronized void m1()throws Exception {

m=1000;

Tread.sleep(5000);

System.out.println(m);

}

public void m2{

m=2000;}

public void run(){

try{ m1(); }catch(){}

}

}

public staticvoid mian (String[] args) throws Exception{

TT tt =new TT();

Thread t = new Thread(tt);

t.start();

tt.m2();

System.out.println(m);

}

进程t先锁定m1方法，改变m为1000，在睡眠，主线程继续执行，通过m2方法改变m为2000，最后m1，m2方法的打印m均为2000.

2.对某一代码块使用，synchronized后跟括号，括号里是变量，这样，一次只有一个线程进入该代码块。public int synMethod(int a1){

synchronized(a1) { //一次只能有一个线程进入}

}

3.synchronized后面括号里是一对象，此时，线程获得的是对象锁。例如：

public class MyThread implements Runnable {

public static void main(String args[]) {

MyThread mt = new MyThread();

Thread t1 = new Thread(mt, "t1");

Thread t2 = new Thread(mt, "t2");

Thread t3 = new Thread(mt, "t3");

t1.start();

t2.start();

t3.start();

}

public void run() {

synchronized (this) {

System.out.println(Thread.currentThread().getName());

}

}

}

对于3,如果线程进入，则得到对象锁，那么别的线程在该类所有对象上的任何操作都不能进行。在对象级使用锁通常是一种比较粗糙的方法。为什么要将整个对象都上锁，而不允许其他线程短暂地使用对象中其他同步方法来访问共享资源？如果一个对象拥有多个资源，就不需要只为了让一个线程使用其中一部分资源，就将所有线程都锁在外面。由于每个对象都有锁，可以如下所示使用虚拟对象来上锁：

class FineGrainLock {

MyMemberClass x, y;

Object xlock = new Object(), ylock = new Object();

public void foo() {

synchronized(xlock) { //access x here

}

synchronized(ylock) { //access y here

}

}

public void bar() {

synchronized(this) {

//access both x and y here

}

4.synchronized后面括号里是类。例如：

class ArrayWithLockOrder{

private static long num_locks = 0;

private long lock_order;

private int[] arr;

public ArrayWithLockOrder(int[] a)

{ arr = a;

synchronized(ArrayWithLockOrder.class) {//--------这里类

num_locks++; // 锁数加1

lock_order = num_locks; }// 为此对象实例设置唯一的lock_order。

}

public long lockOrder()

{ return lock_order; }

public int[] array()

{ return arr; }

}

class SomeClass implements Runnable

{

public int sumArrays(ArrayWithLockOrder a1, ArrayWithLockOrder a2)

{

int value = 0;

ArrayWithLockOrder first = a1; // 保留数组引用的一个ArrayWithLockOrder last = a2; // 本地副本。

int size = a1.array().length;

if (size == a2.array().length)

{

if (a1.lockOrder() > a2.lockOrder()) // 确定并设置对象的锁定

{ // 顺序。

first = a2;

last = a1;

}

synchronized(first) { // 按正确的顺序锁定对象。

synchronized(last) {

int[] arr1 = a1.array();

int[] arr2 = a2.array();

for (int i=0; i value += arr1[i] + arr2[i];

}

}

}

return value;

}

public void run() {

//...

}

}

对于4,如果线程进入，则线程在该类中所有操作不能进行，包括静态变量和静态方法，实际上，对于含有静态方法和静态变量的代码块的同步，我们通常用4来加锁。

以上4种之间的关系：

锁是和对象相关联的，每个对象有一把锁，为了执行synchronized语句，线程必须能够获得synchronized 语句中表达式指定的对象的锁，一个对象只有一把锁，被一个线程获得之后它就不再拥有这把锁，线程在执行完synchronized语句后，将获得锁交还给对象。

在方法前面加上synchronized修饰符即可以将一个方法声明为同步化方法。同步化方法在执行之前获得一个锁。如果这是一个类方法，那么获得的锁是和声明方法的类相关的Class类对象的锁。如果这是一个实例方法，那么此锁是this对象的锁。synchronzied块后面跟类的具体详细例子、public class DB2_JDBCFactory {private static DB2_JDBCFactory instance = null; public static final ThreadLocal threadLocal = new ThreadLocal(); private DB2_JDBCFactory() {

} public static DB2_JDBCFactory getInstance() {

if(instance == null) {

synchronized(DB2_JDBCFactory.class) { //synchronized后面跟一个类

instance = new DB2_JDBCFactory();

}

}

return instance;

} public Connection getConnection_JNDI_localhost(){

Connection c = (Connection) threadLocal.get();

try {

if (c == null || c.isClosed()) {

InitialContext ctx = new InitialContext();

DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/localhost");

c = ds.getConnection();

threadLocal.set(c);

}

} catch (Exception ex) {

System.err.println("getConnection_JNDI Initial failed. " + ex);

return null;

}

return c;

}}外面的对象访问这个类的需要通过调用它的getInstance()

死锁的例子

public class T estDeadLock implements Runnable{

public int flag = 1;

static Object o1 = new Object();

static Object o2 = new Object();

public void run(){

System.out.println("flag="+flag);

/*

if(flag ==1){

synchronized(o1)

{

try{Thread.sleep(5000);}

catch(Exception e){e.printStackTrace();}

}

synchronized(o2)

{

System.out.println("1");

}

} //这种情况是if语句中的两个锁并列，即便没有o2的锁，o1的语句也一样能执行完毕，锁在执行完毕后立即返还，可以供别的对象使用。

if(flag ==1){

synchronized(o1)

{

try{Thread.sleep(5000);}

catch(Exception e){e.printStackTrace();}

synchronized(o2){System.out.println("1");}

}

} //此时有了O1的锁还必须要O2的锁，才能执行完O1语句，从而返还锁O1.

if(flag ==0){

synchronized(o2)

{

try{Thread.sleep(5000);}

catch(Exception e){e.printStackTrace();}

synchronized(o1){System.out.println("0");}

}

}

}

public static void main(String[] args){

TestDeadLock td1 = new TestDeadLock();

TestDeadLock td0 = new TestDeadLock();

td1.flag=1;

td0.flag=0;

Thread t1 = new Thread(td1);

Thread t0 = new Thread(td0);

t1.start();

t0.start();

}

}

线程中使用wait方法，该方法位于java.long.Object中

必须要先有synchronized方法或对象，才能正常调用wait()方法，并且调用wait（）方法后，结束锁定该对象，wait结束则重新锁定该对象

而sleep方法，即便执行了该方法，锁定依旧不结束