java线程的基础知识

1.线程:在现在操作系统中能够独立并发执行的基本单元。
2.线程的特征:<1>.轻量:占用的系统资源极少
<2>.独立:操作系统中可以独立调度和分派的基本单位。
<.3>.共享:共享进程中的资源。
3.Java 中实现线程的三种方法:<1>.继承Thread类,重写run()方法<2>.实现Runnable接口,实现run()方法。<3>通过实现Callable接口。
4.继承自Thread的线程其一个线程对象只能启动一个线程无论调用多少次的start方法,
代码如下:
public class ThreadDemo02 {
public static void main(String[] args){
// ThreadTest t = new ThreadTest();
// t.start();
// t.start();
// t.start();
// t.start();
new ThreadTest().start();
System.out.println(“++++++++++++++++++++++++++”);
new ThreadTest().start(); System.out.println(“—————————”);
new ThreadTest().start();
System.out.println(“============================”);
new ThreadTest().start();
}
}
class ThreadTest extends Thread{
private int ticket = 100;
public void run(){
while(true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+” is Sealing”+ticket–);
}else{
break;
}
}
}
}

5.实现Runnable接口的线程可以实现创建不同的线程对象去访问同一资源。
代码如下:
public class ThreadDemo03 {

/**
 *@methodTitle: main
 *@Description: TODO
 *@param args
 *@returnType: void
 *@author LIU
 *@Date 2015年11月9日上午12:53:04
 */
public static void main(String[] args) {
    Runnable r = new ThreadTest1();
    new Thread(r).start();
    new Thread(r).start();
    new Thread(r).start();
    new Thread(r).start();
}

}
class ThreadTest1 implements Runnable{

/* (non-Javadoc)
 * @see java.lang.Runnable#run()
 */
private int ticket = 100;
@Override
public void run() {
    while(true){
        if(ticket>0){
    System.out.println(Thread.currentThread().getName()+" is sealing ticket"+ticket--);
        }else{
            break;
        }
    }
}

}

6.实现Runnable接口相对于继承Thread类来说,有如下好处:
(1).适合多个相同程序代码的线程去处理同一资源的情况，把虚拟cpu(线程)同程序的代码,数据有效的分离,较好的体现的面向对象的设计思想。
(2).可以避免由于java的单继承性带来的局限性。我们经常碰到这样一种情况,即当我们要将已经继承的某一个类的子类放入多线程汇总,由于一个类不能同时又两个父类，所以不能采用Thread类的方式，那么这个类就只能采用实现Runnable接口的方式了。
(3).有利于程序的健壮性,有利于程序的健壮性,代码能够被多个线程共享,代码与数据是独立的,当多个线程的执行代码来自同一个类的实例时，即称它们共享相同的代码.多个线程操作相同的数据，与他们的代码无关。当共享访问相同的对象时，即他们共享相同的数据，线程被构造时，需要的代码和数据通过一个对象作为构造函数实参传递进去，这个对象就是一个实现了Runnable接口的类的实例。
7.线程的生命周期:
<1>.新建(new):线程刚刚创建完毕。
<2>.可运行(Runnable):启动线程后
<3>.运行(Running):操作系统调度:
<4>.阻塞/等待:等待某种资源或时间片到,当阻塞或者等待的线程被唤醒后其线程的状态转化为可运行的状态。
<5>.消亡:退出run方法
8.一个线程只能运行一次。
9.类方法:下列介绍的方法为静态方法,针对当前运行线程:
<1>.currentThread():获取当前运行线程的引用
<2>.yield():使得当前运行线程放弃当前时间片
<3>.sleep():使得当前运行线程休眠多少时间(单位是毫秒)
10.实例方法:针对指定线程:
<1>.start():启动线程
<2>.setPriority/getPriority:设置/获取线程优先级
<3>.setName/getName:设置/获取线程的名称。
<4>.setDaemon/isDaemon/设置/获取线程的守护线程状态。
12.守护线程会在其他线程完毕后自动消亡。
13.多线程共享数据的问题:
<1>.多线程并发访问同一数据时,容易发生数据状态不稳定。
<2>.java中使用锁的机制实现线程的同步。
14.并发执行锁的规范:
<1>.每一个类一把锁,每一个对象一把锁。
<2>.只有获取锁的线程可以进入同步区域
代码如下:使用对象的锁即同步块机制:
/**
*
*/
package Thread01;

/**
*@ClassName: ThreadDemo05.java
*@Decription: TODO
*@author LIU
*
*@version: V1.0
*@Date: 2015年11月9日下午11:22:05
*/
public class ThreadDemo05 {

/**
 *@methodTitle: main
 *@Description: TODO
 *@param args
 *@returnType: void
 *@author LIU
 *@Date 2015年11月9日下午11:22:05
 */
public static void main(String[] args) {
    Data d = new Data();
    new ThreadTest02(d).start();
    new ThreadTest02(d).start();
}

}
class Data{
int i =0;
public void process(){
synchronized (this) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {

        }
        System.out.println("before:"+i);
        i--;
        System.out.println("after"+i);
    }
}

}
class ThreadTest02 extends Thread{
Data d;
public ThreadTest02(Data d){
this.d = d;
}
public void run(){
while(true){
d.process();
}
}
}
同步块和同步方法的比较:
synchronized(this){

};
synchronized 修饰符 方法名(){

};
同步块的粒度更小即可以对甚至是一个语句加上同步机制。而同步方法的粒度职能是同步方法。同步块获取的锁可以是任意对象的锁而同步方法获取的锁只能是当前对象的锁。
/**
*
*/
package Thread01;

/**
*@ClassName: ThreadDemo05.java
*@Decription: TODO
*@author LIU
*
*@version: V1.0
*@Date: 2015年11月9日下午11:22:05
*/
public class ThreadDemo05 {

/**
 *@methodTitle: main
 *@Description: TODO
 *@param args
 *@returnType: void
 *@author LIU
 *@Date 2015年11月9日下午11:22:05
 */
public static void main(String[] args) {
    Data d = new Data();
    new ThreadTest02(d).start();
    new ThreadTest02(d).start();
}

}
class Data{
int i =0;
public synchronized void process(){
// synchronized (this) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {

        }
        System.out.println("before:"+i);
        i--;
        System.out.println("after"+i);
    }

// }

}
class ThreadTest02 extends Thread{
Data d;
public ThreadTest02(Data d){
this.d = d;
}
public void run(){
while(true){
d.process();
}
}
}