1：线程的概念
进程(任务)：一个正在运行的程序
进程的调度:CPU来决定什么时候该运行哪个进程 (时间片轮流法)
线程在一个应用程序中,同时，有多个不同的执行路径，是进程中的实际运作单位。
好处是提高程序效率。
1.2 线程和进程的关系
a:一个进程可以创建多个线程
b:线程必须依赖于进程而存在
c:多个线程共享进程的空间
d:进程和线程得到CPU的机会是均等的‘
1.3 为什么要搞多线程
我们可以让程序同时执行(并发执行)
//Java只让我们创建线程，而不让我们创建进程
java HelloWorld --->JVM 启动进程
Run Application --->JVM 启动进程
//一个进程中至少要有一个线程
main方法 被称为 主线程
2: 线程的创建方式
Thread 类
方式1：继承Thread类
1:自定义一个类，继承Thread类
2:重写Thread类的run方法
3:创建自定义类对象
4:让自定义类对象调用start方法，启动线程
例题:
package pack01_thread;
public class Demo01Thread {
public static void main(String[] args) {
//3:创建自定义类对象
MyThread mt = new MyThread();
//4:让自定义类对象调用start方法，启动线程
mt.start();
while(true){
System.out.println("主线程");
}
}
}
package pack01_thread;
//创建两个线程
public class Demo02Thread {
public static void main(String[] args) {
MyThread mt1 = new MyThread();
MyThread mt2 = new MyThread();
mt1.start();
mt2.start();
while(true){
System.out.println("主线程");
}
}
}
package pack01_thread;
//创建两个线程
public class Demo03Thread {
public static void main(String[] args) {
MyThread2 mt1 = new MyThread2();
MyThread2 mt2 = new MyThread2();
//设置线程的优先级
mt1.setPriority(Thread.MAX_PRIORITY);
mt2.setPriority(Thread.MIN_PRIORITY);
mt1.start();
mt2.start();
}
}
package pack01_thread;
public class MyThread extends Thread {
public void run() {
while (true) {
//获取线程的名字:getName
System.out.println(getName() + ":线程");
}
}
}
package pack01_thread;
public class MyThread2 extends Thread {
public void run(){
while(true){
//让线程睡眠一秒钟
//模拟网络延时
//try{Thread.sleep(1000);}catch(Exception e){}
System.out.println(getName()+":子线程");
//Thread.yield();
}
}
}
class MyThread extends Thread{
public void run(){
//在此写你线程要执行的代码(木马查杀)
}
}
//-----------------
MyThread mt = new MyThread();
mt.start(); //启动线程----->系统会自动调用run方法
2.2 线程中的小方法
public static void sleep(long millis)//线程执行到该语句，就会休眠---》让出CPU
public static void yield() // 线程的礼让 线程执行到该语句 线程会将CPU的执行权主动让出
// 让线程执行的更加均匀
public final void setPriority(int newPriority) //设置线程的优先级
package pack02_thread;
public class Demo01Thread {
public static void main(String[] args) {
MyRunnable mr = new MyRunnable();
Thread t1 = new Thread(mr, "窗口1");
Thread t2 = new Thread(mr, "窗口2");
//给线程起名字
//t1.setName("线程1");
//t2.setName("线程2");
//这两个线程启动的时候，执行的都是MyRunnable中的run方法
t1.start();
t2.start();
new Thread(mr,"窗口3").start(); //匿名对象创建
}
}
package pack02_thread;
public class Demo02Thread {
public static void main(String[] args) {
//匿名内部类对象来创建线程
new Thread(new Runnable() {
@Override
public void run() {
while(true){
System.out.println(Thread.currentThread().getName()+":线程");
}
}
},"窗口").start();
}
}
package pack02_thread;
public class MyRunnable implements Runnable {
@Override
public void run() {
while(true){
//获取线程的名字
//public static Thread currentThread() //当前线程对象
System.out.println(Thread.currentThread().getName()+":子线程");
}
}
}
package pack03_selltickets;
public class Demo01SellTickets {
public static void main(String[] args) {
//模拟三个窗口来卖票
SellTickets st = new SellTickets();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
创建线程的方式二：实现接口Runnable
步骤 ：
1：自定义类实现Runnable接口
2：重写run方法
3: 创建自定义对象
4：创建Thread类对象，并将自定义类对象作为参数传入Thread类
5: 通过Thread类对象调用start方法启动线程
class MyRunnable implements Runnable
{
public void run(){
//线程要执行的内容
}
}
//----------------
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
t.start();//启动线程,系统会自动执行MyRunnable中的run方法
3: 线程的同步(线程的安全)
a:同一张票被卖了多次
b:出现了负票问题
线程的同步有三种实现方法：
a: 同步代码块
b: 同步方法
c: Lock锁
3.1 同步代码块
synchronized (锁对象) //可以是任何一个对象，必须保证线程共享这个对象
{
//存放你要加锁的代码
}
3.2 同步方法
//同步方法的锁对象是this
//静态方法的锁对象是类的Class对象
public synchronized void sellTickets(){
}
3.3 两者的区别
synchronized (锁对象)
{
xxxxx
yyyyy
zzzzz
sssss
ttttt
}
public synchronized void sellTickets(){
xxxxx
yyyyy
zzzzz
sssss
ttttt
}
//---------------
public void method(){
xxxxx
yyyyy
synchronized (锁对象) {
zzzzz
sssss
ttttt
}
}
//同步方法，用户不能只指定锁对象，默认都是this
//同步代码块，自己可以指定锁对象，锁对象可以是任何对象，只要线程共享即可
3.4 Lock锁
Lock:
ReentrantLock
lock(); 加锁
unlock(); 解锁
1:创建ReentrantLock对象
2：在适当的地方加锁
lock()
2：在适当的地方解锁
unlock();
package pack03_selltickets;
public class SellTickets implements Runnable {
//模拟100张票
int tickets = 100;
//创建一个锁对象
Object obj = new Object();
//模拟卖票
@Override
public void run() {
while(true){
//将if代码块进行了加锁
//T1 T2
synchronized (obj) {
if(tickets > 0){
//会发生网络延时
try {Thread.sleep(50);} catch (InterruptedException e) {}
System.out.println(Thread.currentThread().getName()+"正在出售第"
+ (tickets--)+"张票");
}
}
}
}
}
package pack05_selltickets;
public class Demo01SellTickets {
public static void main(String[] args) {
//模拟三个窗口来卖票
SellTickets st = new SellTickets();
Thread t1 = new Thread(st, "窗口1");
Thread t2 = new Thread(st, "窗口2");
Thread t3 = new Thread(st, "窗口3");
t1.start();
t2.start();
t3.start();
}
}
package pack06_selltickets;
import java.util.Scanner;
public class Demo01SellTickets {
@SuppressWarnings("resource")
public static void main(String[] args) {
模拟三个窗口来卖票
//SellTickets st = new SellTickets();
//
//Thread t1 = new Thread(st, "窗口1");
//Thread t2 = new Thread(st, "窗口2");
//Thread t3 = new Thread(st, "窗口3");
//
//t1.start();
//t2.start();
//t3.start();
}
}
package pack07_selltickets;
import java.util.Scanner;
public class Demo01SellTickets {
public static void main(String[] args) {
new Thread(new SellTickets(true)).start();;
new Thread(new SellTickets(false)).start();;
}
}
package pack07_selltickets;
//证明死锁
//方式1：用筷子左和筷子右证明死锁
package com.baidu_01;
public class Demo5_DeadLock {
//这是两把锁
private static String s1 = "筷子左";
private static String s2 = "筷子右";
public static void main(String[] args) {
new Thread() {
public void run() {
while(true) {
synchronized(s1) {
System.out.println(getName() + "获取" + s1 + "等待" + s2);
synchronized(s2) {
System.out.println(getName() + "拿到" + s2 + "开吃");
}
}
}
}
}.start();
new Thread() {
public void run() {
while(true) {
synchronized(s2) {
System.out.println(getName() +"获取" + s2 + "等待" + s1);
synchronized(s1) {
System.out.println(getName() +"拿到" + s1 + "开吃");
}
}
}
}
}.start();
}
}
//方式2
class MyLock{
public static Object lockA = new Object();
public static Object lockB = new Object();
}
public class SellTickets implements Runnable {
boolean bl;
public SellTickets() {
}
public SellTickets(boolean bl) {
this.bl = bl;
}
@Override
public void run() {
if(bl){
//T1线程
synchronized (MyLock.lockA) { //T1得到A
System.out.println(Thread.currentThread().getName()+":得到lockA");
synchronized (MyLock.lockB) {
System.out.println(Thread.currentThread().getName()+":得到lockA和lockB");
}
}
}else{
//T2线程
synchronized (MyLock.lockB) { //T2得到B
System.out.println(Thread.currentThread().getName()+":得到lockB");
synchronized (MyLock.lockA) {
System.out.println(Thread.currentThread().getName()+":得到lockB和lockA");
}
}
}
}
}
线程的生命周期:
新建:创建线程对象.
就绪状态:有执行的资格,没有执行权.
运行状态:有执行资格,也有执行权.
阻塞状态 : 没有执行资格,没有执行权.
死亡状态:代码执行完毕,线程消亡.
运行 -- (run结束或者stop()) -- 死亡(线程对象变成垃圾)
新建 -(start())-- 就绪 -(抢到了CPU的执行权)-运行 --(sleep()和wait()) --阻塞 -- 就绪状态
运行-(被其他的线程把CPU的执行权给抢走了) -- 就绪
单例设计模式:
package pack08_singleobject;
//懒汉式
public class Worker {
private Worker(){}
private static Worker worker = null;
public static synchronized Worker getWorker(){ //
if(worker == null){
//T1 T2 T3
worker = new Worker();
}
return worker;
}
}
package pack08_singleobject;
//饿汉式
//一个类只允许创建一个对象
public class Student {
//构造方法私有
private Student(){}
//自己创建对象
private static Student stu = new Student();
//对外提供对象
public static Student getStudent(){
return stu;
}
}
package pack08_singleobject;
import java.io.IOException;
public class TestDemo {
public static void main(String[] args) throws IOException {
//Student stu1 = Student.getStudent();
//Student stu2 = Student.getStudent();
//
//System.out.println(stu1 == stu2);
Runtime rt = Runtime.getRuntime();
rt.exec("QQ");
}
}
创建线程第三种方法:
(1)创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
(在Thread线程不能直接和Callable进行使用,所以用子类进行连接)
(2)创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
(在FutureTast的构造方法里面有一个可以传入Callable接口的方法,这样就把封装Callable对象了,并且封装了Callable的Call()方法的返回值)
(3)使用FutureTask对象作为Thread对象的target创建并启动新线程。(用了Thread对象的构造方法可以传入Runnable接口,而Future又是Runnable的接口的实现类)
(4)调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
Callable方法的好处:有返回值,可以抛异常.(Runnable不可以抛异常和不能有返回值)
例题:
package com.baidu_01;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class Demo6_Callable {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建线程池
ExecutorService pool = Executors.newFixedThreadPool(2);
//将线程放进池子里并执行
Future f1 = pool.submit(new MyCallable(100));
Future f2 = pool.submit(new MyCallable(50));
System.out.println(f1.get());
System.out.println(f2.get());
pool.shutdown();
}
}
class MyCallable implements Callable {
private int num;
public MyCallable(int num) {
this.num = num;
}
@Override
public Integer call() throws Exception {
// TODO Auto-generated method stub
int sum = 0;
for(int i = 0 ; i <= num ; i++) {
sum += i;
}
return sum;
}
}
package com.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableThreadTest implements Callable
{
public static void main(String[] args)
{
CallableThreadTest ctt = new CallableThreadTest();
FutureTask ft = new FutureTask<>(ctt);
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i==20)
{
new Thread(ft,"有返回值的线程").start();
}
}
try
{
System.out.println("子线程的返回值："+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}
}
@Override
public Integer call() throws Exception
{
int i = 0;
for(;i<100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}
}
package com.thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableThreadTest implements Callable
{
public static void main(String[] args)
{
MyRunnable mt = new MyRunnable();
Thread t1 = new Thread(mt);
CallableThreadTest ctt = new CallableThreadTest();
FutureTask ft = new FutureTask<>(ctt);
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i==20)
{
Thread target = new Thread(ft,"有返回值的线程").start();
}
}
try
{
System.out.println("子线程的返回值："+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}
}
@Override
public Integer call() throws Exception
{
int i = 0;
for(;i<100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}
}
class MyRunnalbe implements Runnable {
public void run() {
}
}
二、创建线程的三种方式的对比
采用实现Runnable、Callable接口的方式创见多线程时，优势是：
线程类只是实现了Runnable接口或Callable接口，还可以继承其他类。
在这种方式下，多个线程可以共享同一个target对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
劣势是：
编程稍微复杂，如果要访问当前线程，则必须使用Thread.currentThread()方法。
使用继承Thread类的方式创建多线程时优势是：
编写简单，如果需要访问当前线程，则无需使用Thread.currentThread()方法，直接使用this即可获得当前线程。
劣势是：
线程类已经继承了Thread类，所以不能再继承其他父类。
非静态的同步方法的锁对象是神马?
* 答:非静态的同步方法的锁对象是this
* 静态的同步方法的锁对象是什么?
* 是该类的字节码对象.
//锁对象不能用匿名对象,因为匿名对象不是同一个对象
ipconfig:在DOS查看本机IP地址.
从 Java 5 开始，Java 提供了自己的线程池。线程池就是一个线程的容器，每次只执行额定数量的线程。 java.util.concurrent.ThreadPoolExecutor 就是这样的线程池。它很灵活，但使用起来也比较复杂，本文就对其做一个介绍。
首先是构造函数。以最简单的构造函数为例：
public ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue)
看起来挺复杂的。这里介绍一下。
corePoolSize 指的是保留的线程池大小。
maximumPoolSize 指的是线程池的最大大小。
keepAliveTime 指的是空闲线程结束的超时时间。
unit 是一个枚举，表示 keepAliveTime 的单位。
workQueue 表示存放任务的队列。
我们可以从线程池的工作过程中了解这些参数的意义。线程池的工作过程如下：
1、线程池刚创建时，里面没有一个线程。任务队列是作为参数传进来的。不过，就算队列里面有任务，线程池也不会马上执行它们。
2、当调用 execute() 方法添加一个任务时，线程池会做如下判断：
a. 如果正在运行的线程数量小于 corePoolSize，那么马上创建线程运行这个任务；
b. 如果正在运行的线程数量大于或等于 corePoolSize，那么将这个任务放入队列。
c. 如果这时候队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么还是要创建线程运行这个任务；
d. 如果队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会抛出异常，告诉调用者“我不能再接受任务了”。
3、当一个线程完成任务时，它会从队列中取下一个任务来执行。
4、当一个线程无事可做，超过一定的时间(keepAliveTime)时，线程池会判断，如果当前运行的线程数大于 corePoolSize，那么这个线程就被停掉。所以线程池的所有任务完成后，它最终会收缩到 corePoolSize 的大小。
这样的过程说明，并不是先加入任务就一定会先执行。假设队列大小为 10，corePoolSize 为 3，maximumPoolSize 为 6，那么当加入 20 个任务时，执行的顺序就是这样的：首先执行任务 1、2、3，然后任务 4~13 被放入队列。这时候队列满了，任务 14、15、16 会被马上执行，而任务 17~20 则会抛出异常。最终顺序是：1、2、3、14、15、16、4、5、6、7、8、9、10、11、12、13。下面是一个线程池使用的例子：
public static void main(String[] args) {
BlockingQueue queue = new LinkedBlockingQueue();
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.DAYS, queue);
for (int i = 0; i < 20; i++) {
executor.execute(new Runnable() {
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(String.format("thread %d finished", this.hashCode()));
}
});
}
executor.shutdown();
}
对这个例子的说明如下：
1、BlockingQueue 只是一个接口，常用的实现类有 LinkedBlockingQueue 和 ArrayBlockingQueue。用 LinkedBlockingQueue 的好处在于没有大小限制。这样的话，因为队列不会满，所以 execute() 不会抛出异常，而线程池中运行的线程数也永远不会超过 corePoolSize 个，keepAliveTime 参数也就没有意义了。
2、shutdown() 方法不会阻塞。调用 shutdown() 方法之后，主线程就马上结束了，而线程池会继续运行直到所有任务执行完才会停止。如果不调用 shutdown() 方法，那么线程池会一直保持下去，以便随时添加新的任务。
到这里对于这个线程池还只是介绍了一小部分。ThreadPoolExecutor 具有很强的可扩展性，不过扩展它的前提是要熟悉它的工作方式。后面的文章将会介绍如何扩展 ThreadPoolExecutor 类。
ava.util.concurrent.ThreadPoolExecutor 类提供了丰富的可扩展性。你可以通过创建它的子类来自定义它的行为。例如，我希望当每个任务结束之后打印一条消息，但我又无法修改任务对象，那么我可以这样写：
ThreadPoolExecutor executor = new ThreadPoolExecutor(size, maxSize, 1, TimeUnit.DAYS, queue) {
@Override
protected void afterExecute(Runnable r, Throwable t) {
System.out.println("Task finished.");
}
};
除了 afterExecute 方法之外，ThreadPoolExecutor 类还有 beforeExecute() 和 terminated() 方法可以重写，分别是在任务执行之前和整个线程池停止之后执行。
除了可以添加任务执行前后的动作之外， ThreadPoolExecutor 还允许你自定义当添加任务失败后的执行策略。你可以调用线程池的 setRejectedExecutionHandler() 方法，用自定义的 RejectedExecutionHandler 对象替换现有的策略。 ThreadPoolExecutor 提供 4 个现有的策略，分别是：
ThreadPoolExecutor.AbortPolicy：表示拒绝任务并抛出异常
ThreadPoolExecutor.DiscardPolicy：表示拒绝任务但不做任何动作
ThreadPoolExecutor.CallerRunsPolicy：表示拒绝任务，并在调用者的线程中直接执行该任务
ThreadPoolExecutor.DiscardOldestPolicy：表示先丢弃任务队列中的第一个任务，然后把这个任务加进队列。
这里是一个例子：
ThreadPoolExecutor executor = new ThreadPoolExecutor(size, maxSize, 1, TimeUnit.DAYS, queue);
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
除此之外，你也可以通过实现 RejectedExecutionHandler 接口来编写自己的策略。下面是一个例子：
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 6, 1, TimeUnit.SECONDS, queue,
new RejectedExecutionHandler() {
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println(String.format("Task %d rejected.", r.hashCode()));
}
}
);
扫一扫
1281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
