多线程

其实多线程是很复杂，在这里只是作为简单了解：

1.一个线程是进程中的执行流程，一个进程可以同时包含多个线程。

2.若一个进程同时完成多段代码的操作，就需要产生多线程

3.多线程实现方式有两种：

【1】继承java.lang.Thread类

【2】实现java.lang.Runnable接口

 

二．继承自Thread类的多线程

 

1、构造方法：

 

public Thread(String threadName)

 

public Thread()

 

其中第一个构造方法是创建一个名称为threadName的线程对象

 

继承Thread类语法如下：

 

public class Thread ThreadTest extends Thread{

 

}

 

 

 

2、完成线程的真正功能的代码放在类的run()方法中，当一个类继承自Thread类后，就可以在该类中覆盖run()方法，将实现该线程供功能的代码写入run()方法中，然后同时调用Thread类中的start()方法执行线程，也就是调用run()方法。

 

Thread对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run()方法中。run()方法必须使用以下语法格式：

 

public void run() {

 

}

 

 

 

3、当执行一个线程程序时，就自动产生一个线程，主方法正是在这个线程上运行的。当不在启动其它线程时，该程序就为单线程程序，如在本章以前的程序都是单线程程序。主方法线程启动由Java虚拟机负责，程序员负责启动自己的线程。

 

语法如下：

 

public static void main(String[] args) {

 

   new ThreadTest().start();

 

}

 

 

 

 

实例：

package Thread;

public class ThreadTest extends Thread{
    private int count = 10;
    public void run() {
        while (true) {
            System.out.print(count + " ");  //打印count变量
            if(--count == 0) {  //使count变量自减，当自减为0时，退出循环
                return;
            }
        }
    }
    public static void main(String[] args) {
        new ThreadTest().start();
    }

}

说明：在main方法中，使线程执行的是Thread类中的start()方法，start()调用被覆盖的run()方法，如果不调用start()方法，则run()方法则将永远不会启动，在主方法没有调用start()方法之前，Thread对象只是一个实例，而不是一个真正的线程。

 

 

三．实现Runnable接口的多线程

 

(在程序员需要继承其他类（非Thread类时）而且还要使当前类实现多线程，可以通过该Runnable接口实现)

 

语法：

 

public class Thread extends Object implents Runnable

 

[注：实质上Thread类实现了Runnable接口，其中的run()方法正是对Runnable接口中的run()方法]

 

实现Runnable接口的程序将会创建一个Thread对象，并将Runnable对象与Thread对象相关联。

 

Thread构造方法：

 

public Thread(Runnable  r)

 

public Thread(Runnable  r,String  name)

 

使用Runnable接口启动新的线程的步骤如下：

 

(1)建立Runnable对象

 

(2)使用参数为Runnable对象的构造方法创建Thread实例

 

(3)调用start()方法启动线程

 

一句话就是：通过Runnable接口创建线程时程序员首先需要编写一个实现Runnable接口的类，然后实例化该类的对象，这样建立里Runnable对象；接下来使用相应的构造方法创建Thread实例；最后使用该实例调用Thread类中的Start()方法启动线程。

 

实例：

 

package Thread;

import java.awt.Container;
import java.net.URL;
import javax.swing.*;

public class SwingAndThread extends JFrame {

    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() {  //重写润()方法
                          while (count <= 200) {  //设置循环条件
                              //将标签的横坐标用变量来表示
                              jl.setBounds(count, 10, 200, 50);
                              try {
                                  Thread.sleep(10);  //使线程休眠10毫秒
                                  }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对象
    }
}

 

 

 

四．线程的生命周期

7状态：

出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态、死亡状态

 

出生状态是线程被创建时处于的状态，在用户使用该线程实例调用start()方法之前线程都处于出生状态；

当用户调用start()方法后，线程处于就绪状态（又被称为可执行状态）；

当线程得到系统资源后就进入运行状态。

 

一旦线程进入可执行状态，他就会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阻塞或死亡状态。

即处于运行状态下的线程调用Thread类中的wait()方法时，该线程便进入等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而notifyAll()方法是将所有处于等待状态的线程唤醒；

当线程调用Thread类中的sleep()类时，则会进入休眠状态。如果一个线程在运行状态下发出输入/输出请求，即使系统资源空闲，线程依然不能回到运行状态。当线程的run()方法执行完毕时，线程进入死亡状态。

 

【注意：虽然多线程看起来像同时执行，但事实上在同一时间点上只有一个线程被执行，只是线程之间切换比较快，所以才会使人产生线程是同步进行的假象。在window系统中，系统会为每一个线程分配一小段CPU时间片，一旦CPU时间片结束就会将当前线程换位下一个线程，即该线程没有结束】

 

可以使线程处于就绪态的方法有：

调用sleep()方法。

调用wait()方法。

等待输入/输出完成

 

当线程处于就绪态后，可以进入运行态的方法：

线程调用notify()方法

线程调用notifyAll()方法

线程调用interrupt()方法

线程的休眠时间结束

输入/输出结束

 

五．操作线程的方法

【1】休眠：sleep()方法

try {

Thread.sleep(2000);

}catch (Exception  e) {

e.printStackTrrace();

}

 

 

实例：

package Thread;
import java.awt.*;
import java.util.*;

import javax.swing.*;
public class SleepMethodTest extends JFrame {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private Thread t;
    // 定义颜色数组
    private static Color[] color = { Color.BLACK, Color.BLUE, Color.CYAN,
            Color.GREEN, Color.ORANGE, Color.YELLOW, Color.RED,
            Color.PINK, Color.LIGHT_GRAY };
    private static final Random rand = new Random();// 创建随机对象
    
    private static Color getC() {// 获取随机颜色值的方法
        return color[rand.nextInt(color.length)];
    }
    
    public SleepMethodTest() {
        t = new Thread(new Runnable() {// 创建匿名线程对象
            int x = 30;// 定义初始坐标
            int y = 50;
            
            public void run() {// 覆盖线程接口方法
                while (true) {// 无限循环
                    try {
                        Thread.sleep(100);// 线程休眠0.1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 获取组件绘图上下文对象
                    Graphics graphics = getGraphics();
                    graphics.setColor(getC());// 设置绘图颜色
                    // 绘制直线并递增垂直坐标
                    graphics.drawLine(x, y, 100, y++);
                    if (y >= 80) {
                        y = 50;
                    }
                }
            }
        });
        t.start();// 启动线程
    }
    
    public static void main(String[] args) {
        init(new SleepMethodTest(), 100, 100);
    }
    // 初始化程序界面的方法
    public static void init(JFrame frame, int width, int height) {
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(width, height);
        frame.setVisible(true);
    }
}

 

 

【2】线程加入：join()方法

解释：如果当前某程序为多线程程序，假如存在一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后再继续执行线程A，此时可以使用Thread类中的join()方法来完成。

 

实例：

 

package Thread;

import java.awt.*;

import javax.swing.*;

public class JoinTest extends JFrame {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private Thread threadA; // 定义两个线程
    private Thread threadB;
    final JProgressBar progressBar = new JProgressBar(); // 定义两个进度条组件
    final JProgressBar progressBar2 = new JProgressBar();
    int count = 0;
    
    public static void main(String[] args) {
        init(new JoinTest(), 100, 100);
    }
    
    public JoinTest() {
        super();
        // 将进度条设置在窗体最北面
        getContentPane().add(progressBar, BorderLayout.NORTH);
        // 将进度条设置在窗体最南面
        getContentPane().add(progressBar2, BorderLayout.SOUTH);
        progressBar.setStringPainted(true); // 设置进度条显示数字字符
        progressBar2.setStringPainted(true);
        // 使用匿名内部类形式初始化Thread实例子
        threadA = new Thread(new Runnable() {
            int count = 0;
            
            public void run() { // 重写run()方法
                while (true) {
                    progressBar.setValue(++count); // 设置进度条的当前值
                    try {
                        Thread.sleep(100); // 使线程A休眠100毫秒
                        threadB.join(); // 使线程B调用join()方法
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        threadA.start(); // 启动线程A
        threadB = new Thread(new Runnable() {
            int count = 0;
            
            public void run() {
                while (true) {
                    progressBar2.setValue(++count); // 设置进度条的当前值
                    try {
                        Thread.sleep(100); // 使线程B休眠100毫秒
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    if (count == 100) // 当count变量增长为100时
                        break; // 跳出循环
                }
            }
        });
        threadB.start(); // 启动线程B
    }
    
    // 设置窗体各种属性方法
    public static void init(JFrame frame, int width, int height) {
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(width, height);
        frame.setVisible(true);
    }
}

 

 

 

【3】线程中断：stop()在当前版本已废弃不用，所以一般采用在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。

 

实例：

 

package Thread;

public class InterruptedTest implements Runnable{
    private boolean isContinue = false; //设置一个标记变量，默认值为false
    @Override
    public void run() {  //重写润()方法
        while(true) {
            //...
            if (isContinue)  //当isContinue变量为true时，停止线程
                break;
        }
    }
    
    public void setContinue() {  //定义设置isContinue变量为true的方法
        this.isContinue = true;
    }
}

如果线程是因为使用了sleep()或wait()方法进入了就绪状态，可以使用Thread类中interrupt()方法使线程离开run()方法，同时结束线程，但程序会抛出InterruptedException异常，用户可以在处理该异常时完成线程的中断业务处理，如终止while循环。
实战源码：
package Thread;

import java.awt.*;

import javax.swing.*;

public class InterruptedSwing extends JFrame {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    Thread thread;
    
    public static void main(String[] args) {
        init(new InterruptedSwing(), 100, 100);
    }
    
    public InterruptedSwing() {
        super();
        final JProgressBar progressBar = new JProgressBar(); // 创建进度条
        // 将进度条放置在窗体合适位置
        getContentPane().add(progressBar, BorderLayout.NORTH);
        progressBar.setStringPainted(true); // 设置进度条上显示数字
        thread = new Thread(new Runnable() {
            int count = 0;
            
            public void run() {
                while (true) {
                    progressBar.setValue(++count); // 设置进度条的当前值
                    try {
                        Thread.sleep(1000); // 使线程休眠1000豪秒
                        // 捕捉InterruptedException异常
                    } catch (InterruptedException e) {
                        System.out.println("当前线程序被中断");
                        break;
                    }
                }
            }
        });
        thread.start(); // 启动线程
        thread.interrupt(); // 中断线程
    }
    
    public static void init(JFrame frame, int width, int height) {
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(width, height);
        frame.setVisible(true);
    }
    
}

 

 

 

【4】线程优先级：

 

 

【5】线程同步：

目的：防止多线程编程中的资源访问的冲突。

（1）线程安全：

以火车站售票系统为例，在代码中判断当前票数是否大于0，如果大于0则执行将该票售出给乘客的功能，但当两个线程同时访问这段代码时（假设这时只剩一张票），第一个线程将票售出，与此同时第二个线程也已经执行完成判断是否有票的操作，并得出结论票数大于0，于是它也执行售出操作，这样就会产生负数。

总之：在编写多线程程序时，应该考虑到线程安全的问题，实质上线程安全问题来源于两个线程同时存取单一对象的数据。

 

实例：

package Thread;
//注：启动该程序好像会触发java相关网络协议,不知道为什么无穷量占用内存和CPU资源，记得把该程序中断

public class ThreadSafeTest implements Runnable {
    int num = 10;  //设置当前总票数

    @Override
    public void run() {
        while (true) {
            if (num > 0) {
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("ticket" + num--);
            }
        }
    }
    
    public static void main (String[] args) {
        ThreadSafeTest t = new ThreadSafeTest();  //实例化对象
        Thread tA = new Thread(t);  //一该类对象分别实例化4个线程
        Thread tB = new Thread(t);
        Thread tC = new Thread(t);
        Thread tD = new Thread(t);
        tA.start();  //分别启动线程
        tB.start();
        tC.start();
        tD.start();
    }
}

 

（2）线程同步机制（解决资源共享问题）

基本上所有解决多线程资源冲突问题的方法都是采用给定时间只允许一个线程访问共享资源，这时需要给共享资源上一道锁（PV操作啦~）

 

方法一：同步块，提供同步机制，采用synchromized关键字

实例：

 

package Thread;

public class ThreadSafeTest2 implements Runnable {
    int num = 10;  //设置当前总票数

    @Override
    public void run() {
        while(true) {
            synchronized("") {
                if(num > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println("tickets" + --num);
                }
            }
        }
    }
    
    public static void main (String[] args) {
        ThreadSafeTest2 t = new ThreadSafeTest2();  //实例化对象
        Thread tA = new Thread(t);  //一该类对象分别实例化4个线程
        Thread tB = new Thread(t);
        Thread tC = new Thread(t);
        Thread tD = new Thread(t);
        tA.start();  //分别启动线程
        tB.start();
        tC.start();
        tD.start();
    }
}

 

 

方法二：同步方法，就是在方法前面修饰synchronized关键字的方法

语法格式：synchronized void(){}

当某个对象调用了同步方法时，该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为synchronized，否则会出错。

实例：

package Thread;

public class a {
    
    public synchronized void doit() {  //定义同步方法
        int num = 10;
        if(num > 0) {
            try {
                Thread.sleep(10);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("tickets" + --num);
        }
    }
    
    public void run() {
        while (true) {
            doit();  //在run()方法中调用该同步方法
        }
    }

}