Extremely Serious
Add a NuGet package reference to .Net Core project using the following command:
dotnet add package <PACKAGE_NAME> [-v <VERSION>]
Where:
| PACKAGE_NAME | The NuGet package to be added |
| VERSION | If the optional -v was used, the target VERSION of the NuGet package. |
Example without the -v option
dotnet add package Microsoft.ApplicationInsights
Example with the -v option
dotnet add package Microsoft.ApplicationInsights -v 2.10.0
It is recommended to have the following command somewhere in the beginning of the batch file:
cd /d %~dp0
The presence of this will run all the commands after it with respect to the location of the running batch file.
| Name | URL |
|---|---|
| Gradle Plugins | https://plugins.gradle.org/m2/ |
| JCenter | https://jcenter.bintray.com |
| Maven Central | http://central.maven.org/maven2/ |
| Maven Repo1 | https://repo1.maven.org/maven2/ |
If you need an recent openjdk version for ubuntu add the following repository:
sudo add-apt-repository ppa:openjdk-r/ppa
Then do an update like the following:
sudo apt-get update
| Station | Streaming Address |
|---|---|
| Cool FM 90.1 | http://equinox.shoutca.st:8938/stream |
| iFM 93.9 Manila | http://curiosity.shoutca.st:8098/stream |
| 90.7 Love Radio Manila | https://manilabr.radioca.st/stream |
| Magic 107 | http://curiosity.shoutca.st:8098/stream/1/ |
| Star FM Manila 102.7 FM | http://ample-zeno-06.radiojar.com/g1pmt17nz9duv |
| YES! FM 101.1 Manila | http://37.59.28.208:8500/stream |
| Monster RX 93.1 | http://icecast.eradioportal.com:8000/monsterrx |
| Rakista Radio | http://206.190.138.197:8000/stream/1/ |
Create an implementation of ThreadFactory to create a thread with custom name for ThreadPoolExecutor as follows:
class MyThreadFactory implements ThreadFactory {
private AtomicLong threadCounter;
private MyThreadFactory() {
threadCounter = new AtomicLong();
}
@Override
public Thread newThread(Runnable runnable) {
var thread=new Thread(runnable);
thread.setName(String.join("-","my-thread",
String.valueOf(threadCounter.incrementAndGet())));
return thread;
}
}
The preceding class will generate a thread with the name starting with my-thread. Use the instance of this class in constructing the ThreadPoolExecutor as follows:
var executor = new ThreadPoolExecutor(2, 4, 60L, TimeUnit.SECONDS,
new ArrayBlockingQueue<>(100), new MyThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
The preceding declaration creates an instance of ThreadPoolExecutor with 2 core threads, 4 maximum threads, 60 seconds keep alive and supports 100 items in the queue. The queue size is defined by the instance of ArrayBlockingQueue class.
Start all the core threads as follows:
executor.prestartAllCoreThreads();
Using a profiling tool we can search for all the threads whose names starts with my-thread like the following screenshot:
Don't forget to call any shutdown/terminate methods when done using the executor.
If the resource and the module are known, we can use the ModuleLayer to access it like the following snippet.
ModuleLayer.boot().findModule(<MODULE_NAME>).ifPresent(___module -> {
try {
var modResource = ___module.getResourceAsStream(<RESOURCE_NAME>);
} catch (IOException e) {
e.printStackTrace();
}
});
Where:
MODULE_NAME -> the name of the module that has the resource.
RESOURCE_NAME -> the resource of interest.
Pre-requisite
Procedures
git rebase -i master
pick < hash1 > < message1 > pick < hash2 > < message2 > pick < hash3 > < message3 > pick < hash4 > < message4 >
To
pick < hash1 > < message1 > squash < hash2 > < message2 > squash < hash3 > < message3 > squash < hash4 > < message4 >
Reactive stream is gaining traction in the mainstream programming and java has its own implementation via the Flow API. Popular reactive stream implementations are RxJava, Reactor and Akka.
import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;
import java.util.stream.IntStream;
public class Main {
/**
* Sample subscriber implementation.
*/
public static class Subscriber implements Flow.Subscriber<Integer> {
/**
* Holds an instance of Flow.Subscription instance so that we can request what we can handle.
*/
private Flow.Subscription subscription;
/**
* Tracks if the publisher was closed.
*/
private boolean isDone;
/**
* Triggered on the initial subscription.
* @param subscription An instance of Flow.Subscription.
*/
@Override
public void onSubscribe(Flow.Subscription subscription) {
System.out.println("Subscribed");
this.subscription = subscription;
this.subscription.request(1);
}
/**
* Do the actual processing.
* @param item The actual item currently being processed.
*/
@Override
public void onNext(Integer item) {
System.out.println("Processing " + item);
this.subscription.request(1);
}
/**
* Holds how to handle error.
* @param throwable An instance of Throwable.
*/
@Override
public void onError(Throwable throwable) {
throwable.printStackTrace();
}
/**
* Called with the publisher was closed or completed.
*/
@Override
public void onComplete() {
System.out.println("Processing done.");
isDone = true;
}
}
public static void main(String[] args) throws InterruptedException {
//The publisher of the data.
SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();
//The sample subscriber implementation.
Subscriber subscriber = new Subscriber();
//Register a subscriber.
publisher.subscribe(subscriber);
//The sample stream to process.
var intData = IntStream.rangeClosed(1, 10);
//Publish the stream data.
intData.forEach(publisher::submit);
//The publisher is done.
publisher.close();
//Since this is processing is asynchronous wait for everything to be processed.
while(!subscriber.isDone) {
Thread.sleep(10);
}
System.out.println("Done");
}
}
Download older version of java from the following address:
© 2025 Ron and Ella Wiki Page
Theme by Anders Noren — Up ↑
Recent Comments