------- android培训、java培训、期待与您交流！ ----------
黑马程序员____线程
1、进程和线程
进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程。比如在Windows系统中，一个运行的xx.exe就是一个进程。
Java程序的进程里有几个线程:主线程, 垃圾回收线程(后台线程)
线程是指进程中的一个执行任务(控制单元)，一个进程中可以运行多个线程,多个线程可共享数据。
多进程:操作系统中同时运行的多个程序;
多线程:在同一个进程中同时运行的多个任务;
一个进程至少有一个线程，为了提高效率，可以在一个进程中开启多个控制单元。
并发运行。如：多线程下载软件。
可以完成同时运行，但是通过程序运行的结果发现，虽然同时运行，但是每一次结果都不一致。
因为多线程存在一个特性：随机性。
造成的原因：CPU在瞬间不断切换去处理各个线程而导致的。
可以理解成多个线程在抢cpu资源。
多线程下载:此时线程可以理解为下载的通道，一个线程就是一个文件的下载通道，多线程也就是同时开起好几个下载通道.当服务器提供下载服务时，使用下载者是共享带宽的，在优先级相同的情况下，总服务器会对总下载线程进行平均分配。不难理解，如果你线程多的话，那下载的越快。现流行的下载软件都支持多线程。
多线程是为了同步完成多项任务,不是为了提供运行效率,通过提高资源使用效率来提高系统的效率.
线程是在同一时间需要完成多项任务的时候实现的.
线程与进程的比较
线程具有许多传统进程所具有的特征，故又称为轻型进程(Light—Weight Process)或进程元；而把传统的进程称为重型进程(Heavy—Weight Process)，它相当于只有一个线程的任务。在引入了线程的操作系统中，通常一个进程都有若干个线程，至少需要一个线程。
进程与线程的区别：
1.进程有独立的进程空间，进程中的数据存放空间（堆空间和栈空间）是独立的。
2.线程的堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的。
1、继承Thread类
子类覆写父类中的run方法，将线程运行的代码存放在run中。
建立子类对象的同时线程也被创建。
通过调用start方法开启线程。
2、实现Runnable接口
子类覆盖接口中的run方法。
通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。
Thread类对象调用start方法开启线程。
可使用匿名内部类来写
Eg：
package july7;
//线程的两种方法
class MyThread extends Thread{
private String name;
public MyThread(String name) {
super();
this.name = name;
}
publicvoid run(){
System.out.println(name+"启动！");
}
}
class YourThread implements Runnable{
private String name;
public YourThread(String name) {
this.name = name;
}
@Override
publicvoid run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName()+"第"+i+"次启动！");
}
}
}
publicclass Demo1 {
publicstaticvoid main(String[] args) {
for (int i = 0; i < 100; i++) {
if(i == 50){
new MyThread("刘昭").start();
new Thread(new YourThread(""),"章泽天").start();
}
}
}
}
Thread类中run()和start()方法的区别如下：
run()方法:在本线程内调用该Runnable对象的run()方法，可以重复多次调用；
start()方法:启动一个线程，调用该Runnable对象的run()方法，不能多次启动一个
线程；
A extends Thread：
简单
不能再继承其他类了(Java单继承)
同份资源不共享
A implements Runnable:(推荐)
多个线程共享一个目标资源，适合多线程处理同一份资源。
该类还可以继承其他类，也可以实现其他接口。
我的总结：
实现方式，因为避免了单继承的局限性，所以创建线程建议使用第二种方式。
Eg：
package july7;
//线程卖票的例子
class SellTicket extends Thread{
private String name;
privateintnum = 50;
public SellTicket(String name) {
super();
this.name = name;
}
publicvoid run(){
for (int i = 1; i <= num; i++) {
System.out.println(name+"卖出了第"+i+"张票！");
}
}
}
class MySell implements Runnable{
privateintnum = 50;
@Override
publicvoid run() {
for (int i = 1; i <= num; i++) {
System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票！");
}
}
}
publicclass Demo2 {
publicstaticvoid main(String[] args) throws Exception {
new SellTicket("A").start();
new SellTicket("B").start();
new SellTicket("C").start();
new Thread(new MySell(),"D").start();
new Thread(new MySell(),"E").start();
new Thread(new MySell(),"F").start();
for (int i = 10; i > 0; i--) {
System.out.println(i);
Thread.sleep(1000);
}
}
}
为什么要覆盖run方法呢？
Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法.
也就是说Thread类中的run方法，用于存储线程要运行的代码。
Thread类内部有个public的枚举Thread.State，里边将线程的状态分为：
NEW-------新建状态，至今尚未启动的线程处于这种状态。
RUNNABLE-------运行状态，正在 Java 虚拟机中执行的线程处于这种状态。
BLOCKED-------阻塞状态，受阻塞并等待某个监视器锁的线程处于这种状态。
WAITING-------冻结状态，无限期地等待另一个线程来执行某一特定操作的线程处于这种状态。
TIMED_WAITING-------等待状态，等待另一个线程来执行取决于指定等待时间的操作的线程处于这种状态。
TERMINATED-------已退出的线程处于这种状态。
如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。
只要控制住循环，就可以让run方法结束，也就是线程结束。
join方法：调用join方法的线程对象强制运行，该线程强制运行期间，其他线程无法运行，必须等到该线程结束后其他线程才可以运行。
有人也把这种方式成为联合线程
join方法的重载方法:
join(long millis):
join(long millis,int nanos):
通常很少使用第三个方法:
程序无须精确到一纳秒;
计算机硬件和操作系统也无法精确到一纳秒;
Eg：
package july7;
class MyThreadDemo implements Runnable{
@Override
publicvoid run() {
for (int i = 0; i < 50; i++) {
System.out.println(Thread.currentThread().getName()+"正在运行！"+i);
if(i == 25){
try {
new Thread(new MyThreadDemo(),"刘昭").join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
publicclass DemoRe10 {
publicstaticvoid main(String[] args) {
new Thread(new MyThreadDemo(),"刘昭").start();
new Thread(new MyThreadDemo(),"章泽天").start();
}
}
Daemon
后台线程：处于后台运行，任务是为其他线程提供服务。也称为“守护线程”或“精灵线程”。JVM的垃圾回收就是典型的后台线程。
特点：若所有的前台线程都死亡，后台线程自动死亡。
设置后台线程：Thread对象setDaemon(true);
setDaemon(true)必须在start()调用前。否则出现IllegalThreadStateException异常；
前台线程创建的线程默认是前台线程;
判断是否是后台线程：使用Thread对象的isDaemon()方法；
并且当且仅当创建线程是后台线程时，新线程才是后台线程。
sleep
线程休眠:
让执行的线程暂停一段时间，进入阻塞状态。
sleep(long milllis) throws InterruptedException：毫秒
sleep(long millis,int nanos)
throws InterruptedException:毫秒，纳秒
调用sleep()后，在指定时间段之内，该线程不会获得执行的机会。
控制线程之优先级
每个线程都有优先级，优先级的高低只和线程获得执行机会的次数多少有关。
并非线程优先级越高的就一定先执行，哪个线程的先运行取决于CPU的调度;
默认情况下main线程具有普通的优先级，而它创建的线程也具有普通优先级。
Thread对象的setPriority(int x)和getPriority()来设置和获得优先级。
MAX_PRIORITY : 值是10
MIN_PRIORITY : 值是1
NORM_PRIORITY : 值是5(主方法默认优先级)
yield
线程礼让:
暂停当前正在执行的线程对象，并执行其他线程；
Thread的静态方法，可以是当前线程暂停，但是不会阻塞该线程，而是进入就绪状态。所以完全有可能：某个线程调用了yield()之后，线程调度器又把他调度出来重新执行。
导致安全问题的出现的原因：
多个线程访问出现延迟。
线程随机性。
注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。
我们可以通过Thread.sleep(long time)方法来简单模拟延迟情况。
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
Eg：在前面的卖票例子上，在每卖票的前面加上模拟延时的语句！
package july7;
class SellDemo implements Runnable{
privateintnum = 50;
@Override
publicvoid run() {
for (int i = 0; i < 200; i++) {
if(num > 0){
try {
//因为它不可以直接调用getName()方法，所以必须要获取当前线程。
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖出第"+num--+"张票！");
}
}
}
}
publicclass Demo3 {
publicstaticvoid main(String[] args) {
SellDemo s = new SellDemo();
new Thread(s,"A").start();
new Thread(s,"B").start();
new Thread(s,"C").start();
}
}
输出：这样的话，会出现买了第0，甚至-1张票的情况！
三种方法：
同步代码块：
synchronized(obj)
{
//obj表示同步监视器,是同一个同步对象
/**.....
TODO SOMETHING
*/
}
同步方法
格式：
在方法上加上synchronized修饰符即可。（一般不直接在run方法上加！）
synchronized 返回值类型方法名(参数列表)
{
/**.....
TODO SOMETHING
*/
}
同步方法的同步监听器其实的是 this
静态方法的同步
同步方法
同步代码块
static不能和 this连用
静态方法的默认同步锁是当前方法所在类的.class对象
同步锁
jkd1.5后的另一种同步机制：
通过显示定义同步锁对象来实现同步，这种机制，同步锁应该使用Lock对象充当。
在实现线程安全控制中，通常使用ReentrantLock(可重入锁)。使用该对象可以显示地加锁和解锁。
具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。
public class X {
private final ReentrantLock lock = new ReentrantLock();
//定义需要保证线程安全的方法
public void m(){
//加锁
lock.lock();
try{
//... method body
}finally{
//在finally释放锁
lock.unlock();
}
}
}
修改后的例子：
//同步代码块
package july7;
class SellDemo implements Runnable{
privateintnum = 50;
@Override
publicvoid run() {
for (int i = 0; i < 200; i++) {
synchronized (this) {
if(num > 0){
try {
//因为它不可以直接调用getName()方法，所以必须要获取当前线程。
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖出第"+num--+"张票！");
}
}
}
}
}
publicclass Demo3 {
publicstaticvoid main(String[] args) {
SellDemo s = new SellDemo();
new Thread(s,"A").start();
new Thread(s,"B").start();
new Thread(s,"C").start();
}
}
//同步方法
package july7;
//同步方法
class FinalDemo1 implements Runnable {
privateintnum = 50;
@Override
publicvoid run() {
for (int i = 0; i < 100; i++) {
gen();
}
}
publicsynchronizedvoid gen() {
for (int i = 0; i < 100; i++) {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出了第"
+ num-- + "张票！");
}
}
}
}
publicclass Demo6 {
publicstaticvoid main(String[] args) {
FinalDemo1 f = new FinalDemo1();
new Thread(f, "A").start();
new Thread(f, "B").start();
new Thread(f, "C").start();
}
}
//线程同步锁
package july7;
import java.util.concurrent.locks.ReentrantLock;
//同步锁
class FinalDemo2 implements Runnable {
privateintnum = 50;
privatefinal ReentrantLock lock = new ReentrantLock();
@Override
publicvoid run() {
for (int i = 0; i < 100; i++) {
gen();
}
}
publicvoid gen() {
lock.lock();
try{
//for (int i = 0; i < 100; i++) {
if (num > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出了第"
+ num-- + "张票！");
}
//}
}finally{
lock.unlock();
}
}
}
publicclass Demo7 {
publicstaticvoid main(String[] args) {
FinalDemo2 f = new FinalDemo2();
new Thread(f, "A").start();
new Thread(f, "B").start();
new Thread(f, "C").start();
}
}
有一个数据存储空间,划分为两部分,一部分用于存储人的姓名,另一部分用于存储人的性别;
我们的应用包含两个线程,一个线程不停向数据存储空间添加数据(生产者),另一个线程从数据空间取出数据(消费者);
因为线程的不确定性，存在于以下两种情况：
若生产者线程刚向存储空间添加了人的姓名还没添加人的性别，CPU就切换到了消费者线程，消费者线程把姓名和上一个人的性别联系到一起；
生产者放了若干数据，消费者才开始取数据，或者是消费者取完一个数据，还没等到生产者放入新的数据，又重复的取出已取过的数据；
生产者和消费者
wait():让当前线程放弃监视器进入等待，直到其他线程调用同一个监视器并调用notify()或notifyAll()为止。
notify():唤醒在同一对象监听器中调用wait方法的第一个线程。
notifyAll():唤醒在同一对象监听器中调用wait方法的所有线程。
这三个方法只能让同步监听器调用:
在同步方法中: 谁调用
在同步代码块中: 谁调用
wait()、notify()、notifyAll()，这三个方法属于Object 不属于 Thread，这三个方法必须由同步监视对象来调用，两种情况：
1.synchronized修饰的方法，因为该类的默认实例(this)就是同步监视器，所以可以在同步方法中调用这三个方法;
2.synchronized修饰的同步代码块，同步监视器是括号里的对象，所以必须使用该对象调用这三个方法;
可要是我们使用的是Lock对象来保证同步的,系统中不存在隐式的同步监视器对象,那么就不能使用者三个方法了,那该咋办呢?
此时,Lock代替了同步方法或同步代码块,Condition代替了同步监视器的功能;
Condition对象通过Lock对象的newCondition()方法创建;
里面方法包括:
await(): 等价于同步监听器的wait()方法;
signal(): 等价于同步监听器的notify()方法;
signalAll(): 等价于同步监听器的notifyAll()方法;
例子：设置属性
容易出现的问题是：
名字和性别不对应！
线程通信，很好！
package july7;
class Person{
private String name;
private String sex;
private Boolean isimpty = Boolean.TRUE;//内存区为空！
public String getName() {
returnname;
}
publicvoid setName(String name) {
this.name = name;
}
public String getSex() {
returnsex;
}
publicvoid setSex(String sex) {
this.sex = sex;
}
publicvoid set(String name,String sex){
synchronized (this) {
while(!isimpty.equals(Boolean.TRUE)){//不为空的话等待消费者消费！
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = name;//为空的话生产者创造！
this.sex = sex;
isimpty = Boolean.FALSE;//创造结束后修改属性！
this.notifyAll();
}
}
publicvoid get(){
synchronized (this) {
while(!isimpty.equals(Boolean.FALSE)){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("姓名"+getName()+ ", "+"性别"+getSex());
isimpty = Boolean.TRUE;
this.notifyAll();
}
}
}
class Producer implements Runnable{
private Person p;
public Producer(Person p) {
super();
this.p = p;
}
@Override
publicvoid run() {
for (int i = 0; i < 100; i++) {
if( i % 2 == 0){
p.set("刘昭", "男");
}else{
p.set("章泽天", "女");
}
}
}
}
class Consumer implements Runnable{
private Person p;
public Consumer(Person p) {
super();
this.p = p;
}
@Override
publicvoid run() {
for (int i = 0; i < 100; i++) {
p.get();
}
}
}
publicclass Demo9 {
publicstaticvoid main(String[] args) {
Person p = new Person();
new Thread(new Producer(p)).start();
new Thread(new Consumer(p)).start();
}
}
相关推荐
黑马程序员_张孝祥_Java多线程与并发库，视频+代码+资料
黑马程序员_张孝祥_Java多线程与并发库,老师讲的非常仔细,老师很有耐心.欢迎大家下载学习.
day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda表达式 day08_File类、递归 day09_字节流、字符流 day10_缓冲流、转换流、序列化流、Files day11_网络编程 day12_函数式接口 day13_Stream...
NULL 博文链接：https://lvwenwen.iteye.com/blog/1470696
java并发库thread使用，传统线程技术、定时器技术、线程互斥技术，同步通讯技术、多线程共享数据、并发库应用，线程锁技术，阻塞锁、阻塞队列，线程池等应用
1、 面向对象、跨平台性、健壮性、安全性、可移植性、多线程性、动态性等。 2、 JRE（Java Runtime Environment，Java 运行时环境），它相当于操作系统部分，提供了 Java 程序运 行时所需要的基本条件和许多 Java ...
NULL 博文链接：https://huangminwen.iteye.com/blog/1157983
当一个进程中线程有多个时，是多线程。 为什么要用多线程 1，让计算机"同时"做多件事情，节约时间。 2，后台运行程序，提高程序的运行效率.。 3，多线程可以让程序"同时"处理多个事情。 4，...
传智播客_Java培训_毕向东_Java基础[05-多线程]系黑马程序员_毕向东_Java基础视频教程
含面向对象，异常处理和常用类，线程技术，集合框架，IO操作，网络编程，文件操作，反射机制，
|--利用FinalHttp实现多线程断点续传 |--加密之MD5 |--动画Animation详解 |--动画之view左右抖动 |--动画之移动动画 |--动画之组合动画 |--动画之缩放动画ScaleAnimation |--反序列化对象 |--发送短信 读天气 调音量...
Linux系统及编程基础习题答案.pdf
这是一个java写的拼图游戏，用了swing、多线程等知识，可以设置行数列、列数、还有使用多线程写的游戏动画，拼图的图块具有磁贴设计，代码封装性较强，容易移植，纯原创。
黑马程序员_8天快速掌握Android视频 总共67个视频教程，包括：02_搭建Android开发环境，03_创建与启动手机模拟器和学习使用ANDROID操作系统，04_开发与 运行(卸载)第一个ANDROID应用，05_项目的目录结构与安装及...
黑马程序员_8天快速掌握Android视频 总共67个视频教程，包括：02_搭建Android开发环境，03_创建与启动手机模拟器和学习使用ANDROID操作系统，04_开发与 运行(卸载)第一个ANDROID应用，05_项目的目录结构与安装及...
4.客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。各类型客户在其...
精选12种与多线程和并发处理相关的设计模式 264张图表 + 300段Java示例程序 = 轻松学习多线程编程 日本经典多线程入门书，原版长销11年！ 本书适合以下读者阅读 a.对多线程感兴趣的人 b.对Java编程感兴趣的人 c.对...
萌新做的一个简单的Java拼图游戏 启动类：pers.sept.jigsaw1.swing下的...多线程。 下拉列表选择数字可以切换关卡图片，最后的“+”，可以添自己的图片到关卡中。 设有背景音乐 有一键通过按钮 等等，块下载去看看吧。
日本资-深技术作家、《程序员的数学》作者结城浩执笔，264张图表（UML类图、时序图、Timethreads图等）穿插文中，通过类比手法和浅显的语言，逐一讲解与多线程和并发处理相关的12种设计模式。每章附带练习题和答案，...
第1章 Java开发入门一．填空题1. 面向对象，SUN 2. JavaSE，JavaEE，JavaME3.面向对象、跨平台性、支持多线程4. JDK5.bin