您的位置: 首页  >  文章  >  java自学讲义 多线程

java自学讲义 多线程

分类: 文章 • 2025-02-23 16:23:23

本文是学习笔记来自于 How2J网站 强烈推荐!

一.创建线程的三种方法

1.继承Thread类
public class KillThread extends Thread{}

然后在主函数中这样调用:

KillThread killThread1 = new KillThread(gareen,teemo);
killThread1.start();
2.实现Runnable接口
public class Battle implements Runnable{

然后在主函数中这样调用:

Battle battle1 = new Battle(gareen,teemo);
new Thread(battle1).start();
3.匿名类

类似于这样:

 Thread t1= new Thread(){
            public void run(){
                ///Code            
            }
        };
t1.start();

注： 启动线程是start()方法，run()并不能启动一个新的线程

二.常见线程方法

1.sleep方法

线程暂停一会儿, 单位是毫秒ms

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
2.join方法

把某个线程加入到主线程(main线程)的方法

t1.join();
3.线程优先级

设置优先级让某个线程更有机会获得运行的机会:

t1.setPriority(Thread.MAX_PRIORITY);
t1.start();

这个优先级是会自动和运行的系统的任务优先级对应的, Java中的优先级是从1到10;

4.临时暂停

是静态方法, 让其他线程更有机会运行;

Thread.yield();
5.守护线程

守护线程通常会被用来做日志，性能统计等工作。 可以做计时器;

t1.setDaemon(true);

三.同步

多线程的同步问题指的是多个线程同时修改一个数据的时候，可能导致的问题;
比如i++这个操作, 是有可能发生同步问题的:
假设在某一时刻, 线程a进行i++操作, 它会
1.先取出i的值
2.然后计算i+1的值
3.最后把计算出的值存入i变量
在上述的三步中, 有可能在运行第1步和第3步之间, 另外一个线程b也希望进行i++操作, 因为此时线程a还没有把i的值存入, 所以获取到的值仍是没有自增的i, 所以有可能在线程a和b中同时执行i++的结果是i只加了1;
要解决这个问题就是要使用锁:

1.创建一个同步的对象锁
Object someObject =new Object();
synchronized (someObject){
  //此处的代码只有占有了someObject后才可以执行
}
2.使用要操作的对象作为锁
synchronized(account){
  account.credit();
}
3.在对象的方法内部使用锁

在account类的内部credit方法中

public void credit(int num){
	synchronized(this){
		this.balance+=num;
	}
}
4.把synchronized作为方法的关键字修饰符
public synchronized void credit(int num){
	this.balance+=num;
}

四.线程安全的类

如果一个类，其方法都是有synchronized修饰的，那么该类就叫做线程安全的类

1.HashMap和Hashtable

HashMap和Hashtable都实现了Map接口，都是键值对保存数据的方式
区别1：
HashMap可以存放 null
Hashtable不能存放null
区别2：
HashMap不是线程安全的类
Hashtable是线程安全的类

2.StringBuffer和StringBuilder

StringBuffer 是线程安全的
StringBuilder 是非线程安全的

3.ArrayList和Vector的区别

Vector是线程安全的类，而ArrayList是非线程安全的

4.把非线程安全的集合转换为线程安全

借助Collections.synchronizedList可以把ArrayList转换为线程安全的List。
与此类似的，还有HashSet,LinkedList,HashMap等等非线程安全的类，都通过工具类Collections转换为线程安全的

    	List<Integer> list1 = new ArrayList<>();
    	List<Integer> list2 = Collections.synchronizedList(list1);

五.死锁

  1. 线程1 首先占有对象1，接着试图占有对象2
  2. 线程2 首先占有对象2，接着试图占有对象1
  3. 线程1 等待线程2释放对象2
  4. 与此同时，线程2等待线程1释放对象1
    就会。。。一直等待下去，直到天荒地老，海枯石烂，山无棱 ，天地合。。。
    java自学讲义 多线程

六.线程间交互

使用wait和notify做线程间交互:

	public synchronized void recover() {
		hp = hp + 1;
		System.out.printf("%s 回血1点,增加血后，%s的血量是%.0f%n", name, name, hp);
		// 通知那些等待在this对象上的线程，可以醒过来了，如第20行，等待着的减血线程，苏醒过来
		this.notify();
	}

	public synchronized void hurt() {
		if (hp == 1) {
			try {
				// 让占有this的减血线程，暂时释放对this的占有，并等待
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		hp = hp - 1;
		System.out.printf("%s 减血1点,减少血后，%s的血量是%.0f%n", name, name, hp);
	}

这里需要强调的是，wait方法和notify方法，并不是Thread线程上的方法，它们是Object上的方法。

因为所有的Object都可以被用来作为同步对象，所以准确的讲，wait和notify是同步对象上的方法。

wait()的意思是： 让占用了这个同步对象的线程，临时释放当前的占用，并且等待。 所以调用wait是有前提条件的，一定是在synchronized块里，否则就会出错。

notify() 的意思是，通知一个等待在这个同步对象上的线程，你可以苏醒过来了，有机会重新占用当前对象了。

notifyAll() 的意思是，通知所有的等待在这个同步对象上的线程，你们可以苏醒过来了，有机会重新占用当前对象了。

七.线程池

线程池的思路是这样的:

  1. 准备一个任务容器
  2. 一次性启动10个 消费者线程
  3. 刚开始任务容器是空的，所以线程都wait在上面。
  4. 直到一个外部线程往这个任务容器中扔了一个“任务”，就会有一个消费者线程被唤醒notify
  5. 这个消费者线程取出“任务”，并且执行这个任务，执行完毕后，继续等待下一次任务的到来。
  6. 如果短时间内，有较多的任务加入，那么就会有多个线程被唤醒，去执行这些任务。

在整个过程中，都不需要创建新的线程，而是循环使用这些已经存在的线程;

一个自定义线程池的例子:

package multiplethread;
  
import java.util.LinkedList;
  
public class ThreadPool {
  
    // 线程池大小
    int threadPoolSize;
  
    // 任务容器
    LinkedList<Runnable> tasks = new LinkedList<Runnable>();
  
    // 试图消费任务的线程
  
    public ThreadPool() {
        threadPoolSize = 10;
  
        // 启动10个任务消费者线程
        synchronized (tasks) {
            for (int i = 0; i < threadPoolSize; i++) {
                new TaskConsumeThread("任务消费者线程 " + i).start();
            }
        }
    }
  
    public void add(Runnable r) {
        synchronized (tasks) {
            tasks.add(r);
            // 唤醒等待的任务消费者线程
            tasks.notifyAll();
        }
    }
  
    class TaskConsumeThread extends Thread {
        public TaskConsumeThread(String name) {
            super(name);
        }
  
        Runnable task;
  
        public void run() {
            System.out.println("启动： " + this.getName());
            while (true) {
                synchronized (tasks) {
                    while (tasks.isEmpty()) {
                        try {
                            tasks.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    task = tasks.removeLast();
                    // 允许添加任务的线程可以继续添加任务
                    tasks.notifyAll();
  
                }
                System.out.println(this.getName() + " 获取到任务，并执行");
                task.run();
            }
        }
    }
  
}

使用Java自带的线程池:

        ThreadPoolExecutor threadPool= new ThreadPoolExecutor(10, 15, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());
           
        threadPool.execute(new Runnable(){
   
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("任务1");
            }
               
        });

线程初始化的构造器中
第一个参数10 表示这个线程池初始化了10个线程在里面工作
第二个参数15 表示如果10个线程不够用了，就会自动增加到最多15个线程
第三个参数60 结合第四个参数TimeUnit.SECONDS，表示经过60秒，多出来的线程还没有接到活儿，就会回收，最后保持池子里就10个
第四个参数TimeUnit.SECONDS 如上
第五个参数 new LinkedBlockingQueue() 用来放任务的集合
execute用于添加新的任务

八.Lock锁

相同于synchronized关键字, 也可以用Lock对象锁

		Lock lock = new ReentrantLock();

		Thread t1 = new Thread() {
			public void run() {
				try {
					log("线程启动");
					log("试图占有对象：lock");

					lock.lock();

					log("占有对象：lock");
					log("进行5秒的业务操作");
					Thread.sleep(5000);

				} catch (InterruptedException e) {
					e.printStackTrace();
				} finally {
					log("释放对象：lock");
					lock.unlock();
				}
				log("线程结束");
			}
		};

lock对象提供了一个trylock方法, 可以提供一个时间, trylock会在指定时间范围内试图占用，占成功了，就啪啪啪。 如果时间到了，还占用不成功，扭头就走~

				boolean locked = false;
				try {
					log("线程启动");
					log("试图占有对象：lock");

					locked = lock.tryLock(1,TimeUnit.SECONDS);
					if(locked){
						log("占有对象：lock");
						log("进行5秒的业务操作");
						Thread.sleep(5000);
					}
					else{
						log("经过1秒钟的努力，还没有占有对象，放弃占有");
					}

				} catch (InterruptedException e) {
					e.printStackTrace();
				} finally {
					
					if(locked){
						log("释放对象：lock");
						lock.unlock();
					}
				}

使用synchronized方式进行线程交互，用到的是同步对象的wait,notify和notifyAll方法

Lock也提供了类似的解决办法，首先通过lock对象得到一个Condition对象，然后分别调用这个Condition对象的：await, signal,signalAll 方法

总结synchronized和lock的区别:

  1. Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。

  2. Lock可以选择性的获取锁，如果一段时间获取不到，可以放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就能够规避死锁，synchronized必须通过谨慎和良好的设计，才能减少死锁的发生。

  3. synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 所以如果忘记了释放锁，一样会造成死锁。

九.原子性

所谓的原子性操作即不可中断的操作，比如赋值操作

int i = 5;

原子性操作本身是线程安全的
但是像i++这样的操作就不是原子性的

JDK6 以后，新增加了一个包java.util.concurrent.atomic，里面有各种原子类，比如AtomicInteger。
而AtomicInteger提供了各种自增，自减等方法，这些方法都是原子性的。 换句话说，自增方法 incrementAndGet 是线程安全的，同一个时间，只有一个线程可以调用这个方法。

AtomicInteger atomicI =new AtomicInteger();
int i = atomicI.decrementAndGet();
int j = atomicI.incrementAndGet();
int k = atomicI.addAndGet(3);

相关推荐