此文 为垃圾文 本人复习用的 emmm
- 多线程：指的是这个程序（一个进程）运行时产生了不止一个线程
- 并行与并发：
- 并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。
- 并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。
进程和线程的区分
第一种实现方式:通过继承Thread类来实现的 线程
摘要:
code:
package com.java.Thread;
public class MyThread {
public static void main(String[] args){
Apple a1 = new Apple("坏蛋");
a1.start();
Apple a2 = new Apple("好人");
a2.start();
}
}
class Apple extends Thread{
private String name;
public Apple(String name){
this.name = name;
}
public void run(){
for (int i = 1; i < 10; i++){
System.out.println(name+""+i);
}
}
}
每一个线程从的它的创建到销毁都有一个状态 如下是线程的各种状态:
线程的四种状态
然后实现现成的 第二种方式 实现 Runnable接口
code如下:
package cn.java.thread;
public class RunnableDemo {
public static void main(String[] args) {
Test t1 = new Test("haoren");
Test t2 = new Test("hairen");
Thread th1 = new Thread(t1);
Thread th2 = new Thread(t2);
th1.start();
th2.start();
}
}
class Test implements Runnable{
private String name;
public Test(String name){
this.name = name;
}
public void run(){
for(int i=0;i<10;i++){
System.out.println(name+":"+i);
}
}
}
Thread和Runnable的关系
1.Thread是Ruuable的之类
2.实际上Thread和Runable的关系 跟代理设计模式很像， 这里的Thread就是代理类。我们自己所实现的类才是real。
Thread和Runnable的区别
Runable可以共享数据
code如下:
package cn.java.thread;
public class ShareDemo {
public static void main(String[] args) {
Tickets t1 = new Tickets();
Thread th1 = new Thread(t1);
Thread th2 = new Thread(t1);
th1.start();
th2.start();
}
}
class Tickets implements Runnable{
private int ticket = 5;
public void run(){
for(int i=0;i<5;i++){
if(ticket>0)
System.out.print(ticket--);
}
}
}
然后 我说说这里面的 一个叫做jojn()的东东 网上各种帖子众说纷纭 而对他的理解就是 4个字 强制执行 做一个简单的验证吧.
package com.java.Thread;
public class MyJoin {
public static void main(String[] ARGS){
MyThread2 mt1 = new MyThread2();
mt1.setName("线程1");
mt1.start();
for (int i = 0; i < 10; i++) {
if(i==5){
try {
mt1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(i);
}
}
}
class MyThread2 extends Thread {
/*public MyThread(String string) {
}*/
public void run() {
int i = 0;
while (i < 10) {
System.out.println(Thread.currentThread().getName());
i++;
}
}
}
运行结果如下
然后在 说说 interrupt 中断 一个线程意味着在该线程完成任务之前停止其正在进行的一切，有效地中止其当前的操作。线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序。虽然初次看来它可能显得简单，但是，你必须进行一些预警以实现期望的结果。你最好还是牢记以下的几点告诫。
首先，忘掉Thread.stop方法。虽然它确实停止了一个正在运行的线程，然而，这种方法是不安全也是不受提倡的，这意味着，在未来的Java版本中，它将不复存在。
一些轻率的家伙可能被另一种方法Thread.interrupt所迷惑。尽管，其名称似乎在暗示着什么，然而，这种方法并不会中断一个正在运行的线程（待会将进一步说明），正如Listing A中描述的那样。它创建了一个线程，并且试图使用Thread.interrupt方法停止该线程。Thread.sleep()方法的调用，为线程的初始化和中止提供了充裕的时间。线程本身并不参与任何有用的操作。
code如下:
package com.java.Thread;
public class MyInterrupt {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyThread3 mt = new MyThread3();
mt.start();
try {
Thread.sleep(2000);
System.out.println("main休眠结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
mt.interrupt();
}
}
class MyThread3 extends Thread{
public void run(){
System.out.println("进入run");
try {
Thread.sleep(8000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
//e.printStackTrace();
System.out.println("run休眠结束！！！");//sleep被中断会抛出InterruptedException 推荐直接抛出 不要捕获
}
System.out.println("run运行结束");
}
}
然后来到线程礼让 俗话点说 就是 线程A是个君子 看见线程B是个 美女就干什么都让着她 让她先过..
code如下:
package com.java.Thread;
//线程礼让
public class MyYield {
public static void main(String[] ARGS){
MyThred m1 = new MyThred();
Thread t1 = new Thread(m1,"李四");
Thread t2 = new Thread(m1,"王五");
t1.start();
t2.start();
}
}
class MyThred implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++){
System.out.println(Thread.currentThread().getName()+"运行>>>>>" + i);
if (i==2) {
System.out.println("线程礼让");
Thread.currentThread().yield();
}
}
}
}
然后 来到 setdaenmo 后台线程设置
Java中线程分为两种类型：用户线程和守护线程。通过Thread.setDaemon(false)设置为用户线程；通过Thread.setDaemon(true)设置为守护线程。如果不设置次属性，默认为用户线程。
用户线程和守护线程的区别：
1. 主线程结束后用户线程还会继续运行,JVM存活；主线程结束后守护线程和JVM的状态又下面第2条确定。
2.如果没有用户线程，都是守护线程，那么JVM结束（随之而来的是所有的一切烟消云散，包括所有的守护线程）。
code如下:
package com.java.Thread;
public class SetDaemon {
public static void main(String[] ARGS){
Persons p1 = new Persons();
Thread th = new Thread(p1);
th.setDaemon(true);//如果不加此语句就永远无法结束
th.start();
}
}
class Persons implements Runnable{
@Override
public void run() {
while (true){
System.out.println("哈哈哈哈哈哈sss");
}
}
}
然后 设置线程的优先级别 这点要说说 高的不一定会优先执行.
这是定义表
通过 setPriority方法来执行
来到重点中的重点 拿个小本本记住 线程安全
导致线程安全出现的原因:
所以 我们为了解决这个问题 推出了 同步 synchronized
然后同步又有两种模式 一种是同步代码块 另外一种是同步函数 这两种同步加锁的方式不一样 = =且看我细细道来
先看看code
package cn.tread;
public class TicketDemo {
/**
* @param args
*/
public static void main(String[] args) {
Person2 p1 = new Person2("haoren");
Thread t1 = new Thread(p1);
Thread t2 = new Thread(p1);
t1.start();
t2.start();
}
}
class Person2 implements Runnable {
private String name;
private int tickets = 5;
public Person2(String name) {
this.name = name;
}
//同步代码块 需要的锁是 任意对象~
Object object1 = new Object();
public void run() {
for (int i = 0; i < 5; i++) {
synchronized (object1) {//object1就是传说中的锁，要同步必须使用同一个锁
if (tickets > 0) {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tickets--);
}
}
}
}
}
观察上面的代码 我们 有了一个总结 同步代码的锁可以是任意对象
然后是同步的前提
同步的弊端
然后我们说说同步函数
package cn.java.thread;
/*
证明同步函数用的是this这把锁
*/
public class Tickets1 {
/**
* @param args
*/
public static void main(String[] args) {
/*
* GetTickets gt1 = new GetTickets(); GetTickets gt2 = new GetTickets();
* GetTickets gt3 = new GetTickets(); gt1.setName("窗口一");
* gt2.setName("窗口二"); gt3.setName("窗口三"); gt1.start(); gt2.start();
* gt3.start();
*/
GetTickets2 gt = new GetTickets2();
Thread th1 = new Thread(gt, "窗口一");
Thread th2 = new Thread(gt, "窗口二");
Thread th3 = new Thread(gt, "窗口三");
th1.start();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
gt.flag = true;
th2.start();
th3.start();
}
}
class GetTickets2 implements Runnable {
private int tickets = 10;
boolean flag = false;
Object ob = new Object();
public void run() {
if (flag) {
for (int i = 0; i < 10; i++) {
//synchronized (ob) {//如果用ob就无法同步
synchronized (this) {
if (tickets > 0) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+ "卖出" + (tickets--) + "号票"+":同步代码块");
}
}
}
} else {
for (int i = 0; i < 10; i++) {
function();
}
}
}
public synchronized void function() {
if (tickets > 0) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖出"
+ (tickets--) + "号票"+"：同步函数");
}
}
}
/*
* class GetTickets extends Thread{ //private static int tickets = 10; private
* int tickets = 10; public void run(){
*
* for (int i = 0; i < 10; i++) { if(tickets>0){
* System.out.println(Thread.currentThread().getName()+"卖出"+(tickets--)+"号票"); }
* } } }
*/
通过 观察我们不难发现
余下的我在下一个分P写...