一 线程的创建：
1.相关概念：
1）进程：是一个正在执行中的程序，每个进程执行都有一个执行顺序。该顺序是一个执行路径，或叫一个控制单元。
2）线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行。一个进程中至少有一个线程。
3）主线程：Java虚拟机启动的时候会有一个进程java.exe。该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。（其实更细节的说明jvm,jvm启动不止一个线程，还有负责垃圾回收机制的线程）。
2.创建线程：
如何在自定义的代码中，自定义一个线程？通过查找api，java已经提供这类事物的描述。就是thread类。同时可以了解到自定义线程有两种方式。
第一种方式：
步骤：1) 定义类继承Thread类
2) 目的是复写Thread类中的run方法。（目的是让自定义的代码存储在run方法让线程运行）
3) 通过创建Thread类的子类对象，创建线程对象
4) 调用线程的start方法，该方法有两个作用：启动线程和调用执行run方法。
线程状态：
1) 新建：start()
2) 运行：具备执行资格，同时具备执行权；
3) 冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；
4) 临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；
5) 消亡：stop()
示例代码如下：
public class ThreadDemo1 extends Thread {
private int count = 10;
@Override
// 在run方法中定义任务
public void run() {
while (count > 0) {
System.out.println(this.getName() + "(" + count + ")");
count--;
}
}
public static void main(String[] args) {
new ThreadDemo1().start();
new ThreadDemo1().start();
// 由于start方法迅速返回，所以main线程可以执行其他的操作,此时有两个独立的线程在并发运行
System.out.println("新年倒计时：");
}
}新年倒计时：
Thread-0(10)
Thread-0(9)
Thread-0(8)
Thread-0(7)
Thread-0(6)
Thread-0(5)
Thread-0(4)
Thread-0(3)
Thread-0(2)
Thread-0(1)
Thread-1(10)
Thread-1(9)
Thread-1(8)
Thread-1(7)
Thread-1(6)
Thread-1(5)
Thread-1(4)
Thread-1(3)
Thread-1(2)
Thread-1(1)第二种方式：
步骤：1）定义类实现Runnable接口中
2）覆盖Runnable接口中的run方法， 将线程要运行的代码存放在该run方法中。
3）通过thread类建立线程对象。
4）将Runnable接口的子类对象传递给Thread的构造函数。为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。
5) 调用Thread类的start方法开启的线程并调用Runnable接口子类的run方法。
问：为什么要将Rinnable接口的子类对象作为实际参数传递给Thread的构造方法？
答：直接创建Runnable对象，并不是创建线程对象。因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。
所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。因为，自定义的run方法所属的对象时Runnable接口的子类对象，所以要让子线程去指定对象的run方法，就必须明确run方法所属的对象。
示例代码如下：
public class ThreadDemo2 implements Runnable {
private int count = 10;
@Override
// 在run方法中定义要实现的代码
public void run() {
while (count > 0) {
System.out.println(Thread.currentThread().getName() + "(" + count
+ ")");
count--;
}
}
public static void main(String[] args) {
ThreadDemo2 tt = new ThreadDemo2();
new Thread(tt).start();
new Thread(tt).start();
System.out.println("新年倒计时：");
}
}新年倒计时：
Thread-0(10)
Thread-1(10)
Thread-0(9)
Thread-1(8)
Thread-0(7)
Thread-1(6)
Thread-1(4)
Thread-0(5)
Thread-1(3)
Thread-0(2)
Thread-1(1)3. 两种方式的比较：
问：同样是建立两个线程为什么，打印的结果却不相同？
答：实现Runnable接口方式创建线程可以共享同一个目标对象（TreadDemo1 tt=new TreadDemo1();），实现了多个相同线程处理同一份资源，如代码中的成员变量count。
问：实现方式和继承方式创建线程有什么区别？
答：继承方式线程代码代码存放在thread子类run方法中。实现方式线程代码存放在Runnable接口的子类的run方法中。实现方式的好处：避免了单继承的局限性，在定义线程时，建议使用实现方式。
问：为什么要覆盖run方法?
答：Thread类用于描述线程，该类就定义了一个功能，用于存储线程要运行的代码。该代码存储功能就是run方法。
二 多线程的特性：
多个线程都在获取cpu的执行权，cpu执行到谁，就运行谁。明确一点的是，在某一个时刻，只能有一个程序在运行（多核除外）。我们可以形象把多线程的运行行为在互相抢夺cpu执行权。这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长是由cpu决定的。
多线程关系图：
三 线程安全：
1 多线程安全问题的原因：
发现一个线程在执行多条语句时，一个线程对多条语句只执行一部分，并运算同一个数据时，在执行过程中，还没有执行完，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。
涉及到两个因素：
1）多个线程在操作共享数据。
2）有多条语句对共享数据进行运算。
原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。如何进行多句操作共享数据代码的封装呢？Java对于多线程的安全问题提供了专业的解决方式。就是同步代码块。
Synchronized(//对象){<span style="font-family: SimSun;font-size:10px;">//</span><span style="font-family: SimSun;font-size:10px; color: rgb(192, 0, 0);"> </span><span style="font-family: SimSun;font-size:10px;">任意对象都可以。这个对象就是锁。</span>
//需要被同步的代码块
}
//在同步代码块中，对象如同锁。将所有的线程可以在同步执行。没有持有锁的线程即使获取cpu的执行权，也不能执行代码块里的代码，因为没有获取到锁。1)必须要有两个或两个以上的线程。
2)必须是多个线程使用同一个锁。
3.同步的好处与弊端：
好处：解决了多线程的安全问题
弊端：多个线程需要判断锁，较为耗费时间。
4. 如何找到在多线程中出现的问题：
1)明确哪些代码是多线程代码
2)明确共享数据
3)明确多线程运行代码中哪些语句是操作共享数据的
5.关于同步代码还有另外一种写法那就是同步方法：
public synchronized void method() {
//要被同步的代码
}答：方法需要被对象调用。那么函数都有一个所属的对象引用。就是this,所以同步函数使用的锁是this。
public static synchronized void method(){
//需要被同步的代码
} 答：通过验证，发现不是this。因为静态方法中不可以定义this。静态进入内存时，内存中没有本类对象，但一定有该类对应的字节码文件对象。类名.class 该类对象的类型是类名.class，该对象的类型是class。静态的同步 方法，使用的锁是该方法所在的类的字节码文件对像：类名.class。
6.线程安全的经典案例：单例中的懒汉式的线程安全
懒汉式在多线程访问时会产生安全隐患，懒汉式的一般写法如下代码：
class Single {
private static Single s = null;
private Single() {
}
public static Single getInstance() {
if (s == null)
//--->有可能多个线程都执行到这个地方
s = new Single();
return s;
}
}class Single {
private static Single s = null;
private Single() {
}
public static Single getInstance() {
synchronized (Single.class) {
if (s == null)
s = new Single();
return s;
}
}
}关于线程通信的几个重要方法：wait();notify();notifyAll(); 这些方法都使用在同步中，因为要持这监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。
提示：wait和sleep区别： 分析这两个方法，从执行权和锁上来分析：
wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。
sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。
wait：线程会释放执行权，而且线程会释放锁。
sleep：线程会释放执行权，但不释放锁。
通过查看api文档发现上述的几个方法都有在Object类中定义。
问：为什么这些操作线程的方法要定义Object类中呢。
答：因为这些方法在操作同步中线程时，都必须标示它们锁操作线程只有的锁。只有一个锁上的被等待线程，可以被同一个锁上的notify所唤醒。不可以对不同锁上的线程进行唤醒。也就是说等待和唤醒是同一个锁。而锁可以是任意的对象，所以可以被任意的对象调用的方法定义Object类中。
线程通信的经典案例生产者消费者：
class ProuducerConsumer {
public static void main(String args[]) {
SyncStack ss = new SyncStack();
Producer producer = new Producer(ss);
Consumer consumer = new Consumer(ss);
new Thread(producer).start();
new Thread(consumer).start();
}
}
class SyncStack {
int index = 0;
public synchronized void push() {
/*
* if (index == 5) { try { this.wait(); } catch (InterruptedException e)
* { e.printStackTrace(); } }// if应该要用while代替
* 因为i如果catch到exception会跳出if语句往下执行 而while语句会再次判断 index ==6
*/
while (index == 5) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
index++;
this.notify();
}// 而这段程序的加 放前后区别不大 因为i有后面的pop叫醒 他。。。。。。。
public synchronized void pop() {
/* index--; */
if (index == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
index--;
}
}// 先减再执行一段程序和先执行一段程序再减 有很大不同的。。。。。。先减的话会导致程序不能正常结束
// 因为先减的话会导致最后消费第19个Cake时线程会进入wait状态，而生产者已经生产完19个cake从而没有线程去notify它
class Cake {
int id = 0;
Cake(int id) {
this.id = id;
}
}
class Producer implements Runnable {
SyncStack ss = null;
Producer(SyncStack ss) {
this.ss = ss;
}
public void run() {
for (int i = 1; i < 20; i++) {
ss.push();
System.out.println("生产了Cake" + i);
}
}
}
class Consumer implements Runnable {
SyncStack ss = null;
Consumer(SyncStack ss) {
this.ss = ss;
}
public void run() {
try {
Thread.sleep(10000);// 开始生产者可能还没开始生产，先等十秒让生产者生产Cake
} catch (Exception e) {
}
for (int i = 1; i < 20; i++) {
ss.pop();
System.out.println("消费了Cake" + i);
}
}
}
JDK1.5中提供另外多线程的升级解决方案：
将同步Synchronized替换成现实Lock操作，将Object中的wait(),notify,notifyAll替换了Condition对象。该对象可以Lock锁，进行获取对象。该生产者消费者示例中，实现了本方只唤醒对方的操作。
class ProducerConsumerDemo{
public static void main(String args){
Resource r=new Resource();
Producer pro=new Producer();
Consumer con=new Consumer();
Thread t1=new Thread(pro);
Thread t2=new Thread(pro);
Thread t3=new Thread(con);
Thread t4=new Thread(con);
t1.start();
t1.start();
t1.start();
t1.start();
}
}
class Resource{
private String name;
private int count=1;
private boolean flag=false;
private Lock lock=new RecentrantLock();
pricate Condition condition_pro=lock.newCondition();
pricate Condition condition_con=lock.newCondition();
public void set(String name)throws InterruptException{
lock.lock();
try{
while(flag)
condition_pro.await();
this.name=name+"--"+conunt++;
System.out.print(Thread.currentThread().getName()+"...生产者..."+this.name);
flag=true;
condition_con.signal();
}finaly{
lock.unlock();
}
}
}
public void out()throws InterruptException{
lock.lock();
try{
while(!flag)
condition_con.await();
System.out.print(Thread.currentThread().getName()+"...消费者..."+this.name);
flag=false;
condition_pro.signal();
}finaly{
lock.unlock();
}
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource){
this.res=res;
}
public void run(){
while(true){
res.set("+商品+");
}
}}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource){
this.res=res;
}
public void run(){
while(true){
res.out();
}
}
}
终止线程的方法：
有三种方法可以使终止线程。
1.使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
2.使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。
3.使用interrupt方法中断线程。
1.使用退出标志终止线程：
当run方法执行完后，线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求，或是其他的需要循环处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while（true）{……}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。下面给出了一个利用退出标志终止线程的例子。
public class ThreadFlag extends Thread {
public volatile boolean exit = false;
public void run() {
while (!exit)
;
}
public static void main(String[] args) throws Exception {
ThreadFlag thread = new ThreadFlag();
thread.start();
sleep(5000); // 主线程延迟5秒
thread.exit = true; // 终止线程thread
thread.join();
System.out.println("线程退出!");
}
}2. 使用stop方法终止线程：
使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程： thread.stop(); 虽然使用上面的代码可以终止线程，但使用stop方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，因此，并不推荐使用stop方法来终止线程。
3. 使用interrupt方法终止线程：
使用interrupt方法来终端线程可分为两种情况：
1）线程处于阻塞状态，如使用了sleep方法。
2）使用while（！isInterrupted（））{……}来判断线程是否被中断。
在第一种情况下使用interrupt方法，sleep方法将抛出一个InterruptedException例外，而在第二种情况下线程将直接退出。下面的代码演示了在第一种情况下使用interrupt方法。
public class ThreadInterrupt extends Thread
{
public void run()
{
try
{
sleep(50000); // 延迟50秒
}
catch (InterruptedException e)
{
System.out.println(e.getMessage());
}
}
public static void main(String[] args) throws Exception
{
Thread thread = new ThreadInterrupt();
thread.start();
System.out.println("在50秒之内按任意键中断线程!");
System.in.read();
thread.interrupt();
thread.join();// 当线程A执行到了B线程的join()方法时，A线程就会等待。等B线程执行完A才会执行。join可以用来临时加入线程执行。
System.out.println("线程已经退出");
}
}
在50秒之内按任意键中断线程!
sleep interrupted
线程已经退出注意：在Thread类中有两个方法可以判断线程是否通过interrupt方法被终止。一个是静态的方法interrupted（），一个是非静态的方法isInterrupted（），这两个方法的区别是interrupted用来判断当前线是否被中断，而isInterrupted可以用来判断其他线程是否被中断。因此，while （！isInterrupted（））也可以换成while （！Thread.interrupted（））。
join方法:
当线程A执行到了B线程的join()方法时，A线程就会等待。等B线程执行完A才会执行。join可以用来临时加入线程执行。
扫一扫
3795
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
