巷尾的酒吧

启动防火墙

1) 重启后生效
开启： chkconfig iptables on
关闭： chkconfig iptables off   或者 /sbin/chkconfig --level 2345 iptables off

2) 即时生效，重启后失效

service 方式
开启： service iptables start
关闭： service iptables stop

iptables方式

查看防火墙状态：
/etc/init.d/iptables status

暂时关闭防火墙：
/etc/init.d/iptables stop

重启iptables:
/etc/init.d/iptables restart

一、Fedora 启动sshd服务：

1、先确认是否已安装ssh服务：

  [root@localhost ~]# rpm -qa | grep openssh-server

　openssh-server-5.3p1-19.fc12.i686 （这行表示已安装）

  若未安装ssh服务，可输入：

  #yum install openssh-server 

  进行安装

2、修改配置文件

   #vi /etc/ssh/sshd_config

  　#Port 22  监听的端口号，默认是22，可以自定义。

　　#Protocol 2  支持的协议，默认就好，不用修改

　　#PermitRootLogin yes 是否允许root直接登录，最好设置为no

    #MMaxAuthTries 6 最大登录数，默认是6，建议设置为3，防止别人密码穷举。

   修改完配置后，重启SSH服务：

 　[root@localhost ~]# /etc/rc.d/init.d/sshd restart

　  Stopping sshd: [ OK ]

Starting sshd: [ OK ]:

3、查看sshd状态：

   #service sshd status

4、将端口22（或者自定义的其他端口）加到防火墙的设置中，标记为Accept

   #iptables -A INPUT -p tcp --dport 22 -j ACCEPT

（这句很重要，不然外部连接不了。）

   也可以将上述参数加入防火墙配置中：

   #vi /etc/sysconfig/iptables

  加入：-A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT

   保存后重启iptables即可

详情可以查阅 iptables的用法

二、Fedora15/16/17 启动sshd服务：

由于Fedora 15/16使用systemd服务，

1、启动SSH服务与上面有些不同

# systemctl start sshd.service

或者 #service sshd start

也可以用 restart 和 stop控制sshd服务

2、设置系统启动时开启服务

# systemctl enable sshd.service

3、同样也需开启防火墙22端口

   #iptables -A INPUT -p tcp --dport 22 -j ACCEPT

   也可以将上述参数加入防火墙配置中：

   #vi /etc/sysconfig/iptables

   加入：-A INPUT -m state --state NEW -m tcp -p tcp --dport 22 -j ACCEPT

   保存后重启iptables即可

详情可以查阅 iptables的用法

package com.abin.lee.servlet.mythread.thread;

public class Mythread extends Thread{
 private String name;
 public Mythread(String name) {
  this.name=name;
 }
 public void run() {
  synchronized(this.name){
   System.out.println("开始时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   System.out.println("结束时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
 
  }
 }
 
}

package com.abin.lee.servlet.mythread.thread;

public class MythreadTest {
 public static void main(String[] args) {
  Mythread mythread1=new Mythread("ManyThread");
  Mythread mythread2=new Mythread("ManyThread");
  mythread1.start();
  mythread2.start();
 }

}

package com.abin.lee.servlet.mythread.runnable;

public class MyRunnable implements Runnable{
 private String name;
 public MyRunnable(String name) {
  this.name=name;
 }
 public synchronized void run(){
   System.out.println("开始时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("结束时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
 }
}

package com.abin.lee.servlet.mythread.runnable;

public class MyRunnableTest {
 public static void main(String[] args) {
  MyRunnable myRunnable=new MyRunnable("ManyThread");
  Thread thread1=new Thread(myRunnable);
  Thread thread2=new Thread(myRunnable);
  thread1.start();
  thread2.start();
 }
}

package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyCallable implements Callable<String>{
 private String name;
 public MyCallable(String name) {
  this.name=name;
 }
 public String call() throws Exception {
  Lock lock=new ReentrantLock();
  lock.lock();
  String result="";
  try {
   System.out.println("开始时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
   System.out.println("name="+name);
   if(name.equals("ManyThread")){
    result="success";
   }else{
    result="failure";
   }
   try {
    Thread.sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("结束时间："+System.currentTimeMillis()+",线程名字："+Thread.currentThread().getName());
 
  } catch (Exception e) {
   e.printStackTrace();
  }finally{
   lock.unlock();
  }

   return result;
  
 }
 
}

package com.abin.lee.servlet.mythread.callable;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import org.junit.Test;

public class MyCallableTest {
 @Test
 public void testMyCallable() throws InterruptedException, ExecutionException{
  ExecutorService executor=Executors.newFixedThreadPool(3);
  MyCallable myCallable=new MyCallable("ManyThread");
  Future future1=executor.submit(myCallable);
  System.out.println("future1="+future1.get());
  Future future2=executor.submit(myCallable);
  System.out.println("future2="+future2.get());
  Future future3=executor.submit(myCallable);
  System.out.println("future3="+future3.get());
  
 }

}

测试结果：