lineage2/l2j_mobius
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated ThreadProvider class.

Browse Source
This commit is contained in:
MobiusDevelopment 2023-07-12 00:15:01 +03:00
parent a542426d7a
commit b994d54621
32 changed files with 1600 additions and 640 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
L2J_Mobius_01.0_Ertheia/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_02.5_Underground/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_03.0_Helios/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_04.0_GrandCrusade/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_05.0_Salvation/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_05.5_EtinasFate/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_06.0_Fafurion/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_07.0_PreludeOfWar/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_08.2_Homunculus/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_09.2_ReturnOfTheQueenAnt/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_10.2_MasterClass/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_10.3_MasterClass/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_C1_HarbingersOfWar/java/org/l2jmobius/gameserver/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.gameserver.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_C4_ScionsOfDestiny/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_C6_Interlude/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_CT_0_Interlude/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_CT_2.4_Epilogue/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_CT_2.6_HighFive/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_1.0/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_1.5_AgeOfSplendor/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_2.0_Saviors/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_2.5_Zaken/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_2.7_Antharas/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_2.8_SevenSigns/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_2.9.5_Saviors/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_2.9_SecretOfEmpire/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_3.0_TheKamael/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Classic_Interlude/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Essence_4.2_DwellingOfSpirits/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Essence_5.2_FrostLord/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Essence_6.2_Vanguard/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}

70
L2J_Mobius_Essence_6.3_Crusader/java/org/l2jmobius/commons/threads/ThreadProvider.java
View File

@ -1,43 +1,73 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.l2jmobius.commons.threads;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mobius
* ThreadFactory implementation that allows setting a thread name prefix, priority, and daemon status when creating new threads.
* @author Pantelis Andrianakis
* @since October 18th 2022
*/
public class ThreadProvider implements ThreadFactory
{
private final AtomicInteger _id = new AtomicInteger();
private final String _prefix;
private final int _priority;
private final boolean _daemon;
/**
* Creates a new ThreadProvider with the specified prefix, normal thread priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
*/
public ThreadProvider(String prefix)
{
_prefix = prefix + " ";
this(prefix, Thread.NORM_PRIORITY, false);
}
/**
* Creates a new ThreadProvider with the specified prefix and daemon status, and normal thread priority.
* @param prefix the prefix to be used for thread names
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, boolean daemon)
{
this(prefix, Thread.NORM_PRIORITY, daemon);
}
/**
* Creates a new ThreadProvider with the specified prefix and priority, and non-daemon threads.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
*/
public ThreadProvider(String prefix, int priority)
{
this(prefix, priority, false);
}
/**
* Creates a new ThreadProvider with the specified prefix, priority, and daemon status.
* @param prefix the prefix to be used for thread names
* @param priority the priority of the threads
* @param daemon whether the threads should be daemon threads
*/
public ThreadProvider(String prefix, int priority, boolean daemon)
{
_prefix = prefix + " ";
_priority = priority;
_daemon = daemon;
}
/**
* Creates a new Thread with the specified Runnable object and with the properties defined in this ThreadProvider.
* @param runnable the object whose run method is invoked when this thread is started
* @return the created Thread
*/
@Override
public Thread newThread(Runnable runnable)
{
final Thread thread = new Thread(runnable, _prefix + _id.incrementAndGet());
thread.setPriority(Thread.NORM_PRIORITY);
thread.setDaemon(false);
thread.setPriority(_priority);
thread.setDaemon(_daemon);
return thread;
}
}